home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / mint / shells / tcsh602.zoo / tcsh602 / diffs < prev    next >
Text File  |  1993-02-22  |  77KB  |  2,962 lines
  1. diff --context --new-file --recursive ../tcsh-6.02/Makefile ./Makefile
  2. *** ../tcsh-6.02/Makefile    Wed May 20 04:00:52 1992
  3. --- ./Makefile    Sun Feb 21 01:39:52 1993
  4. ***************
  5. *** 7,12 ****
  6. --- 7,16 ----
  7.   # With an input editor, command completion, etc. and ported to all sorts of
  8.   # things; Paul Placeway, CIS Dept., Ohio State University
  9.   #
  10. + 
  11. + CROSSDIR = /usr/users1/mat91/mh1/atari/cross-gcc
  12. + CROSSBIN = $(CROSSDIR)/bin
  13. + 
  14.   SHELL=/bin/sh
  15.   VERSION=6.02
  16.   BUILD=tcsh
  17. ***************
  18. *** 43,55 ****
  19.   
  20.   # gcc 2.0
  21.   # On the sparc, don't use -O2; it breaks setjmp() and vfork()
  22. ! CFLAGS=-O $(INCLUDES)
  23.   
  24.   # gcc-2.1
  25. ! CFLAGS=-O2 $(INCLUDES)
  26.   
  27.   # gcc 2.0+ on linux
  28. ! #CFLAGS=-O6 $(INCLUDES) -finline-functions -fstrength-reduce
  29.   
  30.   #hpux 8.0
  31.   #CFLAGS= $(INCLUDES) +O3 -Aa
  32. --- 47,60 ----
  33.   
  34.   # gcc 2.0
  35.   # On the sparc, don't use -O2; it breaks setjmp() and vfork()
  36. ! #CFLAGS=-O $(INCLUDES)
  37.   
  38.   # gcc-2.1
  39. ! #CFLAGS=-O2 $(INCLUDES)
  40.   
  41.   # gcc 2.0+ on linux
  42. ! # MiNT
  43. ! CFLAGS=-O6 -mbaserel $(INCLUDES) -finline-functions -fstrength-reduce -DNO_CRYPT
  44.   
  45.   #hpux 8.0
  46.   #CFLAGS= $(INCLUDES) +O3 -Aa
  47. ***************
  48. *** 106,112 ****
  49.   ################################################################
  50.   ## LIBES.  Pick one, or roll your own.
  51.   ################################################################
  52. ! LIBES= -ltermcap        ## BSD style things, hpux
  53.   #LIBES= -ltermcap -lcs        ## Mach
  54.   #LIBES= -lcurses        ## Sys V3 w/o networking (and Sys V4)
  55.   #LIBES= -lcurses -lc /usr/ucblib/libucb.a ## Sys V4 with BSDTIMES
  56. --- 111,117 ----
  57.   ################################################################
  58.   ## LIBES.  Pick one, or roll your own.
  59.   ################################################################
  60. ! #LIBES= -ltermcap        ## BSD style things, hpux
  61.   #LIBES= -ltermcap -lcs        ## Mach
  62.   #LIBES= -lcurses        ## Sys V3 w/o networking (and Sys V4)
  63.   #LIBES= -lcurses -lc /usr/ucblib/libucb.a ## Sys V4 with BSDTIMES
  64. ***************
  65. *** 136,142 ****
  66.   #LIBES= -lcurses -lnsl -lsocket -lc /usr/ucblib/libucb.a ## Stardent Vistra
  67.   #LIBES= -ltermcap -lndir -lsocket -ljobs ## masscomp RTU6.0
  68.   #LIBES= -ltermcap -lauth        ## for Ultrix with Enhanced Security
  69. ! 
  70.   
  71.   
  72.   # The difficult choice of a c-compiler...
  73. --- 141,147 ----
  74.   #LIBES= -lcurses -lnsl -lsocket -lc /usr/ucblib/libucb.a ## Stardent Vistra
  75.   #LIBES= -ltermcap -lndir -lsocket -ljobs ## masscomp RTU6.0
  76.   #LIBES= -ltermcap -lauth        ## for Ultrix with Enhanced Security
  77. ! LIBES= -lbtermcap        ## when compiling with -mbaserel in MiNT
  78.   
  79.   
  80.   # The difficult choice of a c-compiler...
  81. ***************
  82. *** 146,151 ****
  83. --- 151,157 ----
  84.   # If you want to take out -traditional, make sure that your sys/ioctl.h
  85.   # is fixed correctly, otherwise you'll be stopped for tty input, or you
  86.   # will lose the editor and job control.
  87. + #CC=     $(CROSSBIN)/cgcc -Wall
  88.   CC=    gcc -Wall 
  89.   #CC=    cc
  90.   #CC=    occ
  91. diff --context --new-file --recursive ../tcsh-6.02/config.h ./config.h
  92. *** ../tcsh-6.02/config.h
  93. --- ./config.h    Sun Feb 21 01:39:54 1993
  94. ***************
  95. *** 0 ****
  96. --- 1,114 ----
  97. + /*
  98. +  * config.h -- configure various defines for tcsh
  99. +  *
  100. +  * All source files should #include this FIRST.
  101. +  *
  102. +  * Edit this to match your system type.
  103. +  */
  104. + 
  105. + #ifndef __MINT__
  106. + #define __MINT__
  107. + #endif
  108. + 
  109. + /****************** System dependant compilation flags ****************/
  110. + /*
  111. +  * POSIX    This system supports IEEE Std 1003.1-1988 (POSIX).
  112. +  */
  113. + #undef POSIX
  114. + 
  115. + /*
  116. +  * POSIXJOBS    This system supports the optional IEEE Std 1003.1-1988 (POSIX)
  117. +  *        job control facilities.
  118. +  */
  119. + #undef POSIXJOBS
  120. + 
  121. + /*
  122. +  * VFORK    This machine has a vfork().  
  123. +  *        It used to be that for job control to work, this define
  124. +  *        was mandatory. This is not the case any more.
  125. +  *        If you think you still need it, but you don't have vfork, 
  126. +  *        define this anyway and then do #define vfork fork.  
  127. +  *        I do this anyway on a Sun because of yellow pages brain damage,
  128. +  *        [should not be needed under 4.1]
  129. +  *        and on the iris4d cause    SGI's fork is sufficiently "virtual" 
  130. +  *        that vfork isn't necessary.  (Besides, SGI's vfork is weird).
  131. +  *        Note that some machines eg. rs6000 have a vfork, but not
  132. +  *        with the berkeley semantics, so we cannot use it there either.
  133. +  */
  134. + #define VFORK
  135. + 
  136. + /*
  137. +  * BSDJOBS    You have BSD-style job control (both process groups and
  138. +  *        a tty that deals correctly
  139. +  */
  140. + #define BSDJOBS
  141. + 
  142. + /*
  143. +  * BSDSIGS    You have 4.2-style signals, rather than USG style.
  144. +  *        Note: POSIX systems should not define this unless they
  145. +  *        have sigvec() and friends (ie: 4.3BSD-RENO, HP-UX).
  146. +  */
  147. + #define BSDSIGS
  148. + 
  149. + /*
  150. +  * BSDTIMES    You have BSD-style process time stuff (like rusage)
  151. +  *        This may or may not be true.  For example, Apple Unix
  152. +  *        (OREO) has BSDJOBS and BSDSIGS but not BSDTIMES.
  153. +  */
  154. + #define BSDTIMES
  155. + 
  156. + /*
  157. +  * BSDNICE    Your system uses setpriority() instead of nice, to
  158. +  *        change a processes scheduling priority
  159. +  */
  160. + #undef BSDNICE
  161. + 
  162. + /*
  163. +  * TERMIO    You have struct termio instead of struct sgttyb.
  164. +  *         This is usually the case for SYSV systems, where
  165. +  *        BSD uses sgttyb. POSIX systems should define this
  166. +  *        anyway, even though they use struct termios.
  167. +  */
  168. + #undef TERMIO
  169. + 
  170. + /*
  171. +  * SYSVREL    Your machine is SYSV based (HPUX, A/UX)
  172. +  *        NOTE: don't do this if you are on a Pyramid -- tcsh is
  173. +  *        built in a BSD universe.
  174. +  *        Set SYSVREL to 1, 2, 3, or 4, depending the version of System V
  175. +  *        you are running. Or set it to 0 if you are not SYSV based
  176. +  */
  177. + #define SYSVREL    0
  178. + 
  179. + /*
  180. +  * YPBUGS    Work around Sun YP bugs that cause expansion of ~username
  181. +  *        to send command output to /dev/null
  182. +  */
  183. + #undef YPBUGS
  184. + 
  185. + /*
  186. +  * SIGVOID    Define this if your signal handlers return void.  On older
  187. +  *        systems, signal returns int, but on newer ones, it returns void.
  188. +  */
  189. + #define SIGVOID 
  190. + 
  191. + /*
  192. +  * HAVEDUP2    Define this if your system supports dup2().
  193. +  */
  194. + #define HAVEDUP2
  195. + 
  196. + /*
  197. +  * UTHOST    Does the utmp file have a host field?
  198. +  */
  199. + #define UTHOST
  200. + 
  201. + /*
  202. +  * DIRENT    Your system has <dirent.h> instead of <sys/dir.h>
  203. +  */
  204. + #define DIRENT
  205. + /****************** local defines *********************/
  206. + /****************** configurable hacks ****************/
  207. + /* have been moved to config_f.h */
  208. + #include "config_f.h"
  209. + 
  210. + #undef NLS
  211. diff --context --new-file --recursive ../tcsh-6.02/config_f.h ./config_f.h
  212. *** ../tcsh-6.02/config_f.h    Wed May 20 04:00:52 1992
  213. --- ./config_f.h    Sun Feb 21 01:39:46 1993
  214. ***************
  215. *** 95,101 ****
  216.    *        on the name of the tty, and environment.
  217.    *        Does not make sense in the modern window systems!
  218.    */
  219. ! #define AUTOLOGOUT
  220.   
  221.   /*
  222.    * SUSPENDED    Newer shells say 'Suspended' instead of 'Stopped'.
  223. --- 95,101 ----
  224.    *        on the name of the tty, and environment.
  225.    *        Does not make sense in the modern window systems!
  226.    */
  227. ! #undef AUTOLOGOUT
  228.   
  229.   /*
  230.    * SUSPENDED    Newer shells say 'Suspended' instead of 'Stopped'.
  231. ***************
  232. *** 117,122 ****
  233. --- 117,133 ----
  234.    */
  235.   #undef SYSMALLOC
  236.   
  237. + /*
  238. +  * DOSFS    Support DOS filessystems (which have a 12345678.123 limit),
  239. +  *        and allow backslashes as path separators
  240. +  */
  241. + #define DOSFS
  242. + 
  243. + /*
  244. +  * DOSTEXT    Support DOS text mode/files (ignore ^D)
  245. +  */
  246. + #define DOSTEXT
  247. + 
  248.   /*
  249.    * RCSID    This defines if we want rcs strings in the binary or not
  250.    *
  251. diff --context --new-file --recursive ../tcsh-6.02/ed.init.c ./ed.init.c
  252. *** ../tcsh-6.02/ed.init.c    Wed May 20 04:00:46 1992
  253. --- ./ed.init.c    Sun Feb 21 01:39:22 1993
  254. ***************
  255. *** 624,630 ****
  256. --- 624,648 ----
  257.       char    buf[BUFSIZE];
  258.   
  259.       chrs = read(SHIN, buf, (size_t) min(chrs, BUFSIZE - 1));
  260. + 
  261. + # ifdef DOSTEXT
  262. +     /* strip out carriage returns */
  263.       if (chrs > 0) {
  264. +         char *src, *dst;
  265. +         int i;
  266. + 
  267. +         src = dst = buf;
  268. +         for (i = chrs; i > 0; --i) {
  269. +             if (*src == '\r')
  270. +                 --chrs;
  271. +             else
  272. +                 *dst++ = *src;
  273. +             src++;
  274. +         }
  275. +     }
  276. + # endif
  277. + 
  278. +     if (chrs > 0) {
  279.           buf[chrs] = '\0';
  280.           Input_Line = Strsave(str2short(buf));
  281.           PushMacro(Input_Line);
  282. diff --context --new-file --recursive ../tcsh-6.02/ed.inputl.c ./ed.inputl.c
  283. *** ../tcsh-6.02/ed.inputl.c    Wed May 20 04:00:46 1992
  284. --- ./ed.inputl.c    Sun Feb 21 01:39:24 1993
  285. ***************
  286. *** 91,97 ****
  287. --- 91,102 ----
  288.       if (!Tty_raw_mode && MacroLvl < 0) {
  289.       long    chrs = 0;
  290.   
  291. + # ifndef __MINT__
  292. + /* MiNT _always_ wants to go into raw mode, so don't bother with the
  293. +  * FIONREAD test
  294. +  */
  295.       (void) ioctl(SHIN, FIONREAD, (ioctl_t) & chrs);
  296. + # endif
  297.       if (chrs == 0) {
  298.           if (Rawmode() < 0)
  299.           return 0;
  300. diff --context --new-file --recursive ../tcsh-6.02/pathnames.h ./pathnames.h
  301. *** ../tcsh-6.02/pathnames.h    Wed May 20 04:00:52 1992
  302. --- ./pathnames.h    Sun Feb 21 01:39:46 1993
  303. ***************
  304. *** 54,59 ****
  305. --- 54,65 ----
  306.   # define _PATH_DOTCSHRC        "/etc/cshrc"
  307.   #endif /* convex || __convex__ || stellar || INTEL */
  308.   
  309. + #ifdef DOSFS
  310. + # define _PATH_DOTLOGIN         "/etc/login.csh"
  311. + # define _PATH_DOTLOGOUT        "/etc/logout.csh"
  312. + # define _PATH_DOTCSHRC         "/etc/cshrc.csh"
  313. + #endif
  314. + 
  315.   #if defined(sgi) || defined(OREO) || defined(cray) || defined(AMIX)
  316.   # define _PATH_DOTLOGIN        "/etc/cshrc"
  317.   #endif /* sgi || OREO || cray || AMIX */
  318. diff --context --new-file --recursive ../tcsh-6.02/sh.c ./sh.c
  319. *** ../tcsh-6.02/sh.c    Wed May 20 04:00:38 1992
  320. --- ./sh.c    Sun Feb 21 01:38:50 1993
  321. ***************
  322. *** 124,129 ****
  323. --- 124,134 ----
  324.   static    void          mailchk    __P((void));
  325.   static    Char         **defaultpath    __P((void));
  326.   
  327. + #ifdef __MINT__
  328. + static    Char        **defaultsuffixes __P((void));
  329. + void    importsuffixes    __P((Char *));
  330. + #endif
  331. + 
  332.   int
  333.   main(argc, argv)
  334.       int     argc;
  335. ***************
  336. *** 216,221 ****
  337. --- 221,237 ----
  338.                      tempv[1][0] == '-' && tempv[1][1] == 'l' &&
  339.                           tempv[1][2] == '\0');
  340.   #endif
  341. + 
  342. + #ifdef __MINT__
  343. +     /* under MiNT, we're also a login shell if we ran from the desktop and
  344. +      * have no arguments
  345. +      */
  346. +     if (!loginsh && tempv[0][0] == 0 && !tempv[1]) {
  347. +         loginsh = 1;
  348. +         tempv[0] = "-tcsh";
  349. +     }
  350. + #endif
  351. + 
  352.       if (loginsh && **tempv != '-') {
  353.       /*
  354.        * Mangle the argv space
  355. ***************
  356. *** 502,507 ****
  357. --- 518,533 ----
  358.       else
  359.       importpath(SAVE(tcp));
  360.   
  361. + #ifdef __MINT__
  362. +     /*
  363. +      * set the suffix search list
  364. +      */
  365. +     if ((tcp = getenv("SUFFIXES")) == NULL)
  366. +         set1(STRsuffixes, defaultsuffixes(), &shvhed);
  367. +     else
  368. +         importsuffixes(SAVE(tcp));
  369. + #endif
  370. + 
  371.       set(STRshell, Strsave(STR_SHELLPATH));
  372.   
  373.       doldol = putn((int) getpid());    /* For $$ */
  374. ***************
  375. *** 708,713 ****
  376. --- 734,749 ----
  377.        */
  378.       if (nofile == 0 && argc > 0) {
  379.       nofile = open(tempv[0], O_RDONLY);
  380. + #ifdef __MINT__
  381. +     /* maybe the user tried to execute "foo.csh" as just "foo"
  382. +      */
  383. +     if (nofile < 0) {
  384. +             char *cshfile = alloca(strlen(tempv[0]) + 5);
  385. +             strcpy(cshfile, tempv[0]);
  386. +             strcat(cshfile, ".csh");
  387. +             nofile = open(cshfile, O_RDONLY);
  388. +     }
  389. + #endif
  390.       if (nofile < 0) {
  391.           child = 1;        /* So this ... */
  392.           /* ... doesn't return */
  393. ***************
  394. *** 1920,1925 ****
  395. --- 1956,1965 ----
  396.   #endif
  397.       int     i;
  398.   {
  399. + #ifdef __MINT__
  400. +     void rm_tmpfiles();
  401. +     rm_tmpfiles();            /* remove temporary files, see below */
  402. + #endif
  403.   #ifdef TESLA
  404.       if (loginsh && do_logout) {
  405.       /* this is to send hangup signal to the develcon */
  406. ***************
  407. *** 1986,1988 ****
  408. --- 2026,2165 ----
  409.       *blkp = NULL;
  410.       return (blk);
  411.   }
  412. + 
  413. + #ifdef __MINT__
  414. + /*
  415. +  * unlink() doesn't always work on an open file, so we try to arrange
  416. +  * to remove temporary files (e.g. for here documents) before exiting.
  417. +  */
  418. + 
  419. + struct tmpfile_rec {
  420. +     char *name;    /* the name of the temp. file */
  421. +     int pid;    /* the associated pid */
  422. +     struct tmpfile_rec *next;
  423. + } *root;
  424. + 
  425. + extern int __mint;
  426. + 
  427. + int
  428. + csh_tmpfile()
  429. + {
  430. +     extern char *tmpnam();
  431. +     struct tmpfile_rec *u;
  432. +     int fd;
  433. +     char *name;
  434. + 
  435. +     if ( !(name = tmpnam((char *)0)) )
  436. +         return -1;
  437. + 
  438. +     fd = open(name, O_CREAT|O_EXCL|O_RDWR, 0600);
  439. +     if (fd < 0) {
  440. +         free(name);
  441. +         return -1;
  442. +     }
  443. + 
  444. + /* in MiNT 0.9 and above, we can often unlink a file and continue to use
  445. +  * it; some file systems may return EACCDN for unlinking an open file,
  446. +  * in which case we use the old method of unlinking the file at exit
  447. +  */
  448. +     if (__mint >= 9) {
  449. +         if (unlink(name) == 0)
  450. +             return fd;
  451. +     }
  452. + 
  453. + /* if the unlink failed, save the name for future deleting */
  454. + 
  455. +     u = (struct tmpfile_rec *)malloc(sizeof(*u));
  456. +     if (!u) {
  457. + /* would it be better to fail? I dunno, but at worst the user is left
  458. +  * with a junk file in a temporary directory
  459. +  */
  460. +         return fd;
  461. +     }
  462. + 
  463. +     u->name = name;
  464. +     u->pid = getpid();
  465. +     u->next = root;
  466. +     root = u;
  467. +     return fd;
  468. + }
  469. + 
  470. + void
  471. + rm_tmpfiles()
  472. + {
  473. +     int pid = getpid();
  474. +     struct tmpfile_rec **old, *u;
  475. + 
  476. +     old = &root;
  477. +     u = root;
  478. +     while (u) {
  479. +         if (u->pid == pid) {
  480. +             (void) unlink(u->name);
  481. +             *old = u->next;
  482. +         } else {
  483. +             old = &u->next;
  484. +         }
  485. +         u = u->next;
  486. +     }
  487. + }
  488. + 
  489. + /* MiNT suffix stuff
  490. +  */
  491. + 
  492. + void
  493. + importsuffixes(cp)
  494. +     Char   *cp;
  495. + {
  496. +     register int i = 0;
  497. +     register Char *dp;
  498. +     register Char **pv;
  499. +     int     c;
  500. + 
  501. +     for (dp = cp; *dp; dp++)
  502. +     if (*dp == ',')
  503. +         i++;
  504. +     /*
  505. +      * i+2 where i is the number of ',' in the suffix list. There are i+1
  506. +      * suffixes plus we need room for a zero terminator.
  507. +      */
  508. +     pv = (Char **) xcalloc((size_t) (i + 2), sizeof(Char *));
  509. +     dp = cp;
  510. +     i = 0;
  511. +     if (*dp)
  512. +     for (;;) {
  513. +         if ((c = *dp) == ',' || c == 0) {
  514. +         *dp = 0;
  515. +         pv[i++] = Strsave(cp);
  516. +         if (c) {
  517. +             cp = dp + 1;
  518. +             *dp = ',';
  519. +         }
  520. +         else
  521. +             break;
  522. +         }
  523. +         dp++;
  524. +     }
  525. +     pv[i] = 0;
  526. +     set1(STRsuffixes, pv, &shvhed);
  527. + }
  528. + 
  529. + static Char **
  530. + defaultsuffixes()
  531. + {
  532. +     Char  **blk, **blkp;
  533. + 
  534. +     blkp = blk = (Char **) xmalloc((size_t) sizeof(Char *) * 9);
  535. + 
  536. +     *blkp++ = SAVE("ttp");
  537. +     *blkp++ = SAVE("prg");
  538. +     *blkp++ = SAVE("tos");
  539. +     *blkp++ = SAVE("app");
  540. +     *blkp++ = SAVE("gtp");
  541. +     *blkp++ = SAVE("csh");
  542. +     *blkp++ = SAVE("");
  543. +     *blkp = NULL;
  544. + 
  545. +     return (blk);
  546. + }
  547. + 
  548. + #endif /* __MINT__ */
  549. diff --context --new-file --recursive ../tcsh-6.02/sh.char.c ./sh.char.c
  550. *** ../tcsh-6.02/sh.char.c    Wed May 20 04:00:38 1992
  551. --- ./sh.char.c    Sun Feb 21 01:38:56 1993
  552. ***************
  553. *** 51,57 ****
  554. --- 51,62 ----
  555.       _CTR,        _CTR|_SP|_META,    _CTR|_NL|_META,    _CTR,
  556.   
  557.   /*     12 np         13 cr         14 so         15 si    */
  558. + #ifndef DOSTEXT
  559.       _CTR,        _CTR,        _CTR,        _CTR,
  560. + #else
  561. + /* cr is whitespace */
  562. +     _CTR,        _CTR|_SP|_META,    _CTR,        _CTR,
  563. + #endif
  564.   
  565.   /*     16 dle         17 dc1         18 dc2         19 dc3    */
  566.       _CTR,        _CTR,        _CTR,        _CTR,
  567. diff --context --new-file --recursive ../tcsh-6.02/sh.dir.c ./sh.dir.c
  568. *** ../tcsh-6.02/sh.dir.c    Wed May 20 04:00:38 1992
  569. --- ./sh.dir.c    Sun Feb 21 01:38:52 1993
  570. ***************
  571. *** 228,234 ****
  572.       len = Strlen(hp);
  573.       if (!(dirflag & DIR_LONG) && hp != NULL && !eq(hp, STRslash) &&
  574.           Strncmp(hp, dp->di_name, len) == 0 &&
  575. !         (dp->di_name[len] == '\0' || dp->di_name[len] == '/')) 
  576.           len = Strlen(s = (dp->di_name + len)) + 2;
  577.       else
  578.           len = Strlen(s = dp->di_name) + 1;
  579. --- 228,234 ----
  580.       len = Strlen(hp);
  581.       if (!(dirflag & DIR_LONG) && hp != NULL && !eq(hp, STRslash) &&
  582.           Strncmp(hp, dp->di_name, len) == 0 &&
  583. !         (dp->di_name[len] == '\0' || is_dirsep(dp->di_name[len]))) 
  584.           len = Strlen(s = (dp->di_name + len)) + 2;
  585.       else
  586.           len = Strlen(s = dp->di_name) + 1;
  587. ***************
  588. *** 295,301 ****
  589.   {
  590.   
  591.   /* return true if dp is of the form "../xxx" or "/../xxx" */
  592. ! #define HASDOTDOT(sp, p) (ISDOTDOT(p) && ((p) == (sp) || *((p) - 1) == '/'))
  593.   
  594.   #ifdef S_IFLNK
  595.       if (exp) {
  596. --- 295,301 ----
  597.   {
  598.   
  599.   /* return true if dp is of the form "../xxx" or "/../xxx" */
  600. ! #define HASDOTDOT(sp, p) (ISDOTDOT(p) && ((p) == (sp) || is_dirsep(*((p) - 1))))
  601.   
  602.   #ifdef S_IFLNK
  603.       if (exp) {
  604. ***************
  605. *** 325,331 ****
  606.        * If the path starts with a slash, we are not relative to
  607.        * the current working directory.
  608.        */
  609. !     if ( *start == '/' )
  610.           *cwd = '\0';
  611.   # ifdef apollo
  612.       slashslash = cwd[0] == '/' && cwd[1] == '/';
  613. --- 325,331 ----
  614.        * If the path starts with a slash, we are not relative to
  615.        * the current working directory.
  616.        */
  617. !     if ( is_abspath(start) )
  618.           *cwd = '\0';
  619.   # ifdef apollo
  620.       slashslash = cwd[0] == '/' && cwd[1] == '/';
  621. ***************
  622. *** 356,362 ****
  623.   
  624.           *dp = '\0';
  625.           while (dotdot > 0) 
  626. !             if ((dp = Strrchr(cwd, '/')) != NULL) {
  627.   # ifdef apollo
  628.               if (dp == &cwd[1]) 
  629.                   slashslash = 1;
  630. --- 356,362 ----
  631.   
  632.           *dp = '\0';
  633.           while (dotdot > 0) 
  634. !             if ((dp = Lastslash(cwd)) != NULL) {
  635.   # ifdef apollo
  636.               if (dp == &cwd[1]) 
  637.                   slashslash = 1;
  638. ***************
  639. *** 384,396 ****
  640.   # endif /* apollo */
  641.   
  642.           if (buf[0]) {
  643. !             if ((TRM(cwd[(dotdot = Strlen(cwd)) - 1])) != '/')
  644.               cwd[dotdot++] = '/';
  645.               cwd[dotdot] = '\0';
  646. !             dp = Strspl(cwd, TRM(buf[0]) == '/' ? &buf[1] : buf);
  647.               xfree((ptr_t) cwd);
  648.               cwd = dp;
  649. !             if ((TRM(cwd[(dotdot = Strlen(cwd)) - 1])) == '/')
  650.               cwd[--dotdot] = '\0';
  651.           }
  652.           if (!*cp)
  653. --- 384,396 ----
  654.   # endif /* apollo */
  655.   
  656.           if (buf[0]) {
  657. !             if (! is_dirsep(TRM(cwd[(dotdot = Strlen(cwd)) - 1])))
  658.               cwd[dotdot++] = '/';
  659.               cwd[dotdot] = '\0';
  660. !             dp = Strspl(cwd, is_dirsep(buf[0]) ? &buf[1] : buf);
  661.               xfree((ptr_t) cwd);
  662.               cwd = dp;
  663. !             if (is_dirsep(TRM(cwd[(dotdot = Strlen(cwd)) - 1])))
  664.               cwd[--dotdot] = '\0';
  665.           }
  666.           if (!*cp)
  667. ***************
  668. *** 463,469 ****
  669.   {
  670.       Char   *dp;
  671.   
  672. !     if (*cp != '/') {
  673.       register Char *p, *q;
  674.       int     cwdlen;
  675.   
  676. --- 463,469 ----
  677.   {
  678.       Char   *dp;
  679.   
  680. !     if (! is_abspath(cp)) {
  681.       register Char *p, *q;
  682.       int     cwdlen;
  683.   
  684. ***************
  685. *** 537,543 ****
  686.       serrno = errno;
  687.       }
  688.   
  689. !     if (cp[0] != '/' && !prefix(STRdotsl, cp) && !prefix(STRdotdotsl, cp)
  690.       && (c = adrof(STRcdpath))) {
  691.       Char  **cdp;
  692.       register Char *p;
  693. --- 537,543 ----
  694.       serrno = errno;
  695.       }
  696.   
  697. !     if ((! is_abspath(cp)) && !prefix(STRdotsl, cp) && !prefix(STRdotdotsl, cp)
  698.       && (c = adrof(STRcdpath))) {
  699.       Char  **cdp;
  700.       register Char *p;
  701. ***************
  702. *** 568,574 ****
  703.       }
  704.       }
  705.       dp = value(cp);
  706. !     if ((dp[0] == '/' || dp[0] == '.') && chdir(short2str(dp)) >= 0) {
  707.       xfree((ptr_t) cp);
  708.       cp = Strsave(dp);
  709.       printd = 1;
  710. --- 568,574 ----
  711.       }
  712.       }
  713.       dp = value(cp);
  714. !     if ((is_abspath(dp) || dp[0] == '.') && chdir(short2str(dp)) >= 0) {
  715.       xfree((ptr_t) cp);
  716.       cp = Strsave(dp);
  717.       printd = 1;
  718. ***************
  719. *** 796,806 ****
  720.        * christos: if the path given does not start with a slash prepend cwd. If
  721.        * cwd does not start with a slash or the result would be too long abort().
  722.        */
  723. !     if (*cp != '/') {
  724.       Char    tmpdir[MAXPATHLEN];
  725.   
  726.       p1 = value(STRcwd);
  727. !     if (p1 == NULL || *p1 != '/')
  728.           abort();
  729.       if (Strlen(p1) + Strlen(cp) + 1 >= MAXPATHLEN)
  730.           abort();
  731. --- 796,806 ----
  732.        * christos: if the path given does not start with a slash prepend cwd. If
  733.        * cwd does not start with a slash or the result would be too long abort().
  734.        */
  735. !     if (! is_abspath(cp)) {
  736.       Char    tmpdir[MAXPATHLEN];
  737.   
  738.       p1 = value(STRcwd);
  739. !     if (p1 == NULL || (! is_abspath(p1)))
  740.           abort();
  741.       if (Strlen(p1) + Strlen(cp) + 1 >= MAXPATHLEN)
  742.           abort();
  743. ***************
  744. *** 812,818 ****
  745.       }
  746.   
  747.   #ifdef COMMENT
  748. !     if (*cp != '/')
  749.       abort();
  750.   #endif /* COMMENT */
  751.   
  752. --- 812,818 ----
  753.       }
  754.   
  755.   #ifdef COMMENT
  756. !     if (! is_abspath(cp))
  757.       abort();
  758.   #endif /* COMMENT */
  759.   
  760. ***************
  761. *** 822,828 ****
  762.   
  763.       while (*p) {        /* for each component */
  764.       sp = p;            /* save slash address */
  765. !     while (*++p == '/')    /* flush extra slashes */
  766.           continue;
  767.       if (p != ++sp)
  768.           for (p1 = sp, p2 = p; (*p1++ = *p2++) != '\0';)
  769. --- 822,828 ----
  770.   
  771.       while (*p) {        /* for each component */
  772.       sp = p;            /* save slash address */
  773. !     while (is_dirsep(*++p))    /* flush extra slashes */
  774.           continue;
  775.       if (p != ++sp)
  776.           for (p1 = sp, p2 = p; (*p1++ = *p2++) != '\0';)
  777. ***************
  778. *** 830,836 ****
  779.       p = sp;            /* save start of component */
  780.       slash = 0;
  781.       while (*++p)        /* find next slash or end of path */
  782. !         if (*p == '/') {
  783.           slash = 1;
  784.           *p = 0;
  785.           break;
  786. --- 830,836 ----
  787.       p = sp;            /* save start of component */
  788.       slash = 0;
  789.       while (*++p)        /* find next slash or end of path */
  790. !         if (is_dirsep(*p)) {
  791.           slash = 1;
  792.           *p = 0;
  793.           break;
  794. ***************
  795. *** 880,891 ****
  796.            */
  797.           for (p1 = p; *p1++;)
  798.               continue;
  799. !         if (*link != '/') {
  800.               /*
  801.                * Relative path, expand it between the "yyy/" and the
  802.                * "/..". First, back sp up to the character past "yyy/".
  803.                */
  804. !             while (*--sp != '/')
  805.               continue;
  806.               sp++;
  807.               *sp = 0;
  808. --- 880,891 ----
  809.            */
  810.           for (p1 = p; *p1++;)
  811.               continue;
  812. !         if (! is_abspath(link)) {
  813.               /*
  814.                * Relative path, expand it between the "yyy/" and the
  815.                * "/..". First, back sp up to the character past "yyy/".
  816.                */
  817. !             while (! is_dirsep(*--sp))
  818.               continue;
  819.               sp++;
  820.               *sp = 0;
  821. ***************
  822. *** 934,940 ****
  823.   #endif                /* S_IFLNK */
  824.           *sp = '/';
  825.           if (sp != cp)
  826. !         while (*--sp != '/')
  827.               continue;
  828.           if (slash) {
  829.           for (p1 = sp + 1, p2 = p + 1; (*p1++ = *p2++) != '\0';)
  830. --- 934,940 ----
  831.   #endif                /* S_IFLNK */
  832.           *sp = '/';
  833.           if (sp != cp)
  834. !         while (! is_dirsep(*--sp))
  835.               continue;
  836.           if (slash) {
  837.           for (p1 = sp + 1, p2 = p + 1; (*p1++ = *p2++) != '\0';)
  838. ***************
  839. *** 971,983 ****
  840.            */
  841.           for (p1 = p; *p1++;)
  842.               continue;
  843. !         if (*link != '/') {
  844.               /*
  845.                * Relative path, expand it between the "yyy/" and the
  846.                * remainder. First, back sp up to the character past
  847.                * "yyy/".
  848.                */
  849. !             while (*--sp != '/')
  850.               continue;
  851.               sp++;
  852.               *sp = 0;
  853. --- 971,983 ----
  854.            */
  855.           for (p1 = p; *p1++;)
  856.               continue;
  857. !         if (! is_abspath(link)) {
  858.               /*
  859.                * Relative path, expand it between the "yyy/" and the
  860.                * remainder. First, back sp up to the character past
  861.                * "yyy/".
  862.                */
  863. !             while (! is_dirsep(*--sp))
  864.               continue;
  865.               sp++;
  866.               *sp = 0;
  867. ***************
  868. *** 1038,1045 ****
  869.       /*
  870.        * See if we're not in a subdir of STRhome
  871.        */
  872. !     if (p1 && *p1 == '/' &&
  873. !     (Strncmp(p1, cp, cc) != 0 || (cp[cc] != '/' && cp[cc] != '\0'))) {
  874.       static ino_t home_ino = (ino_t) -1;
  875.       static dev_t home_dev = -1;
  876.       static Char *home_ptr = NULL;
  877. --- 1038,1045 ----
  878.       /*
  879.        * See if we're not in a subdir of STRhome
  880.        */
  881. !     if (p1 && is_abspath(p1) &&
  882. !     (Strncmp(p1, cp, cc) != 0 || ((! is_dirsep(cp[cc])) && cp[cc] != '\0'))) {
  883.       static ino_t home_ino = (ino_t) -1;
  884.       static dev_t home_dev = -1;
  885.       static Char *home_ptr = NULL;
  886. ***************
  887. *** 1064,1070 ****
  888.               sp = (Char *) - 1;
  889.               break;
  890.           }
  891. !         if ((sp = Strrchr(p2, '/')) != NULL)
  892.           *sp = '\0';
  893.       }
  894.       /*
  895. --- 1064,1070 ----
  896.               sp = (Char *) - 1;
  897.               break;
  898.           }
  899. !         if ((sp = Lastslash(p2)) != NULL)
  900.           *sp = '\0';
  901.       }
  902.       /*
  903. diff --context --new-file --recursive ../tcsh-6.02/sh.dol.c ./sh.dol.c
  904. *** ../tcsh-6.02/sh.dol.c    Wed May 20 04:00:38 1992
  905. --- ./sh.dol.c    Sun Feb 21 01:38:52 1993
  906. ***************
  907. *** 444,449 ****
  908. --- 444,455 ----
  909.       if (dimen)
  910.           stderror(ERR_NOTALLOWED, "$?#");
  911.       for (np = wbuf; read(OLDSTD, &tnp, 1) == 1; np++) {
  912. + #ifdef DOSTEXT
  913. +         /* strip out cr's */
  914. +             while (tnp == '\r') {
  915. +                 if (read(OLDSTD, &tnp, 1) != 1) break;
  916. +             }
  917. + #endif
  918.           *np = (unsigned char) tnp;
  919.           if (np >= &wbuf[BUFSIZE - 1])
  920.           stderror(ERR_LTOOLONG);
  921. ***************
  922. *** 873,878 ****
  923. --- 879,895 ----
  924.       register Char *lbp, *obp, *mbp;
  925.       Char  **vp;
  926.       bool    quoted;
  927. + 
  928. + #ifdef __MINT__
  929. +     int tf;
  930. +     extern int csh_tmpfile __P((void));   /* in sh.c */
  931. + 
  932. +     tf = csh_tmpfile();
  933. +     if (tf < 0)
  934. +         stderror(ERR_SYSTEM, "tmpfile", strerror(errno));
  935. +     (void)dup2(tf, 0);
  936. +     (void)close(tf);
  937. + #else
  938.       char   *tmp;
  939.   
  940.       if (creat(tmp = short2str(shtemp), 0600) < 0)
  941. ***************
  942. *** 886,891 ****
  943. --- 903,910 ----
  944.       stderror(ERR_SYSTEM, tmp, strerror(errno));
  945.       }
  946.       (void) unlink(tmp);        /* 0 0 inode! */
  947. + #endif
  948. + 
  949.       Dv[0] = term;
  950.       Dv[1] = NULL;
  951.       gflag = 0;
  952. diff --context --new-file --recursive ../tcsh-6.02/sh.exec.c ./sh.exec.c
  953. *** ../tcsh-6.02/sh.exec.c    Wed May 20 04:00:38 1992
  954. --- ./sh.exec.c    Sun Feb 21 01:38:54 1993
  955. ***************
  956. *** 49,54 ****
  957. --- 49,60 ----
  958.   # define FASTHASH    /* Fast hashing is the default */
  959.   #endif /* OLDHASH */
  960.   
  961. + #ifdef __MINT__
  962. + extern char **environ;
  963. + int    csh_execve    __P((char *, char **, char **));
  964. + #define execv(f, t) csh_execve(f, t, environ)
  965. + #endif
  966. + 
  967.   /*
  968.    * System level search and execute of a command.
  969.    * We look in each directory for the specified command name.
  970. ***************
  971. *** 180,190 ****
  972.   #endif
  973.   
  974.       v = adrof(STRpath);
  975. !     if (v == 0 && expath[0] != '/') {
  976.       blkfree(pv);
  977.       pexerr();
  978.       }
  979. !     slash = any(short2str(expath), '/');
  980.   
  981.       /*
  982.        * Glob the argument list, if necessary. Otherwise trim off the quote bits.
  983. --- 186,196 ----
  984.   #endif
  985.   
  986.       v = adrof(STRpath);
  987. !     if (v == 0 && (! is_abspath(expath))) {
  988.       blkfree(pv);
  989.       pexerr();
  990.       }
  991. !     slash = hasslash(short2str(expath));
  992.   
  993.       /*
  994.        * Glob the argument list, if necessary. Otherwise trim off the quote bits.
  995. ***************
  996. *** 266,272 ****
  997.        * one at a time, as the user enters them.  This is kinda like Korn
  998.        * Shell's "tracked aliases".
  999.        */
  1000. !     if (!slash && pv[0][0] == '/' && havhash) {
  1001.   #ifdef FASTHASH
  1002.           if (!bit(hashval, i))
  1003.           goto cont;
  1004. --- 272,278 ----
  1005.        * one at a time, as the user enters them.  This is kinda like Korn
  1006.        * Shell's "tracked aliases".
  1007.        */
  1008. !     if (!slash && is_abspath(pv[0]) && havhash) {
  1009.   #ifdef FASTHASH
  1010.           if (!bit(hashval, i))
  1011.           goto cont;
  1012. ***************
  1013. *** 377,383 ****
  1014. --- 383,393 ----
  1015.        */
  1016.       if ((fd = open(f, O_RDONLY)) != -1) {
  1017.           if (read(fd, (char *) &c, 1) == 1) {
  1018. + #ifndef DOSTEXT
  1019.           if (!Isprint(c) && (c != '\n' && c != '\t')) {
  1020. + #else
  1021. +         if (!Isprint(c) && (c != '\n' && c != '\r' && c != '\t')) {
  1022. + #endif
  1023.               (void) close(fd);
  1024.               /*
  1025.                * We *know* what ENOEXEC means.
  1026. ***************
  1027. *** 404,410 ****
  1028. --- 414,422 ----
  1029.   #ifdef _PATH_BSHELL
  1030.           if (fd != -1 
  1031.   # ifndef ISC    /* Compatible with ISC's /bin/csh */
  1032. + #  ifndef __MINT__ /* Compensate for missing #! interpretation */
  1033.           && c != '#'
  1034. + #  endif /* __MINT__ */
  1035.   # endif /* ISC */
  1036.           )
  1037.           vp[0] = STR_BSHELL;
  1038. ***************
  1039. *** 580,585 ****
  1040. --- 592,601 ----
  1041.       struct varent *v = adrof(STRpath);
  1042.       Char  **pv;
  1043.       int hashval;
  1044. + #ifdef __MINT__
  1045. +     struct varent *suffv = adrof(STRsuffixes);
  1046. +     Char **suffpv;
  1047. + #endif
  1048.   
  1049.   #ifdef FASTHASH
  1050.       if (vv && vv[1]) {
  1051. ***************
  1052. *** 620,626 ****
  1053.       if (v == NULL)
  1054.       return;
  1055.       for (pv = v->vec; *pv; pv++, i++) {
  1056. !     if (pv[0][0] != '/')
  1057.           continue;
  1058.       dirp = opendir(short2str(*pv));
  1059.       if (dirp == NULL)
  1060. --- 636,642 ----
  1061.       if (v == NULL)
  1062.       return;
  1063.       for (pv = v->vec; *pv; pv++, i++) {
  1064. !     if (! is_abspath(pv[0]))
  1065.           continue;
  1066.       dirp = opendir(short2str(*pv));
  1067.       if (dirp == NULL)
  1068. ***************
  1069. *** 639,644 ****
  1070. --- 655,673 ----
  1071.           (dp->d_name[1] == '\0' ||
  1072.            (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
  1073.           continue;
  1074. + #ifdef __MINT__
  1075. +             {   char *s = rindex(dp->d_name, '.');
  1076. + 
  1077. +                 if (s && suffv) {
  1078. +                     for (suffpv = suffv->vec; *suffpv; suffpv++) {
  1079. +                         if (!strcmp(s+1, short2str(*suffpv))) {
  1080. +                             *s = 0; break;
  1081. +                         }
  1082. +                     }
  1083. +                 }
  1084. +             }
  1085. + #endif /* __MINT__ */
  1086. + 
  1087.   #ifdef FASTHASH
  1088.           hashval = hashname(str2short(dp->d_name));
  1089.           bis(hashval, i);
  1090. ***************
  1091. *** 712,718 ****
  1092.       register Char **pv;
  1093.       register Char *sav;
  1094.       register struct varent *v;
  1095. !     register bool slash = any(short2str(name), '/');
  1096.       register int hashval, i;
  1097.   
  1098.       v = adrof(STRpath);
  1099. --- 741,747 ----
  1100.       register Char **pv;
  1101.       register Char *sav;
  1102.       register struct varent *v;
  1103. !     register bool slash = hasslash(short2str(name));
  1104.       register int hashval, i;
  1105.   
  1106.       v = adrof(STRpath);
  1107. ***************
  1108. *** 724,730 ****
  1109.       hashval = havhash ? hashname(name) : 0;
  1110.       i = 0;
  1111.       do {
  1112. !     if (!slash && pv[0][0] == '/' && havhash) {
  1113.   #ifdef FASTHASH
  1114.           if (!bit(hashval, i))
  1115.           goto cont;
  1116. --- 753,759 ----
  1117.       hashval = havhash ? hashname(name) : 0;
  1118.       i = 0;
  1119.       do {
  1120. !     if (!slash && is_abspath(pv[0]) && havhash) {
  1121.   #ifdef FASTHASH
  1122.           if (!bit(hashval, i))
  1123.           goto cont;
  1124. ***************
  1125. *** 770,775 ****
  1126. --- 799,857 ----
  1127.    * if dir_ok is set and the pathname refers to a directory.
  1128.    * This is a bit kludgy, but in the name of optimization...
  1129.    */
  1130. + #ifdef __MINT__
  1131. + int
  1132. + executable(dir, name, dir_ok)
  1133. +     Char   *dir, *name;
  1134. +     bool    dir_ok;
  1135. + {
  1136. +     char *ext, *base;
  1137. +     int i;
  1138. +     struct stat stbuf;
  1139. +     Char    path[MAXPATHLEN + 1];
  1140. +     char   *strname;
  1141. +     struct varent *v;
  1142. +     Char **pv;
  1143. + 
  1144. +     if (dir && *dir) {
  1145. +         copyn(path, dir, MAXPATHLEN);
  1146. +         catn(path, name, MAXPATHLEN);
  1147. +         strname = short2str(path);
  1148. +     }
  1149. +     else
  1150. +         strname = short2str(name);
  1151. + 
  1152. +     ext = base = alloca(strlen(strname) + 5);
  1153. +     while (*strname)
  1154. +         *ext++ = *strname++;
  1155. + 
  1156. +     *ext = 0;
  1157. + 
  1158. +     if (stat(base, &stbuf) != -1 &&
  1159. +         ((dir_ok && S_ISDIR(stbuf.st_mode)) ||
  1160. +           (S_ISREG(stbuf.st_mode) &&
  1161. +           ((stbuf.st_mode & (S_IXOTH|S_IXGRP|S_IXUSR))))))
  1162. +                 return 1;
  1163. + 
  1164. +     if (dir_ok) return 0;
  1165. + 
  1166. +     v = adrof(STRsuffixes);
  1167. +     if (v == 0) return 0;
  1168. +     
  1169. +     *ext++ = '.';
  1170. +     for (pv = v->vec; *pv; pv++) {
  1171. +         strcpy(ext, short2str(*pv));
  1172. +         if (stat(base, &stbuf) != -1 &&
  1173. +             (S_ISREG(stbuf.st_mode) &&
  1174. +              ((stbuf.st_mode & (S_IXOTH|S_IXGRP|S_IXUSR)) ||
  1175. +               !strcmp(ext, "csh"))))
  1176. +                return 1;
  1177. +     }
  1178. +     return 0;
  1179. + }
  1180. + 
  1181. + #else /* __MINT__ */
  1182. + 
  1183.   int
  1184.   executable(dir, name, dir_ok)
  1185.       Char   *dir, *name;
  1186. ***************
  1187. *** 795,800 ****
  1188. --- 877,884 ----
  1189.             access(strname, X_OK) == 0)));
  1190.   }
  1191.   
  1192. + #endif /* __MINT__ */
  1193. + 
  1194.   void
  1195.   tellmewhat(lex)
  1196.       struct wordent *lex;
  1197. ***************
  1198. *** 853,859 ****
  1199.       if ((i = iscommand(strip(sp->word))) != 0) {
  1200.       register Char **pv;
  1201.       register struct varent *v;
  1202. !     bool    slash = any(short2str(sp->word), '/');
  1203.   
  1204.       v = adrof(STRpath);
  1205.       if (v == 0 || v->vec[0] == 0 || slash)
  1206. --- 937,943 ----
  1207.       if ((i = iscommand(strip(sp->word))) != 0) {
  1208.       register Char **pv;
  1209.       register struct varent *v;
  1210. !     bool    slash = hasslash(short2str(sp->word));
  1211.   
  1212.       v = adrof(STRpath);
  1213.       if (v == 0 || v->vec[0] == 0 || slash)
  1214. ***************
  1215. *** 918,924 ****
  1216.       Char *sv;
  1217.       int hashval, i, ex, rval = 0;
  1218.   
  1219. !     if (prt && any(short2str(cmd), '/')) {
  1220.       xprintf("where: / in command makes no sense\n");
  1221.       return 0;
  1222.       }
  1223. --- 1002,1008 ----
  1224.       Char *sv;
  1225.       int hashval, i, ex, rval = 0;
  1226.   
  1227. !     if (prt && hasslash(short2str(cmd))) {
  1228.       xprintf("where: / in command makes no sense\n");
  1229.       return 0;
  1230.       }
  1231. ***************
  1232. *** 985,987 ****
  1233. --- 1069,1110 ----
  1234.       xfree((ptr_t) sv);
  1235.       return rval;
  1236.   }
  1237. + 
  1238. + #ifdef __MINT__
  1239. + 
  1240. + #include <process.h>
  1241. + 
  1242. + int
  1243. + csh_execve(path, argv, envp)
  1244. +         char *path;
  1245. +         char **argv, **envp;
  1246. + {
  1247. +         int i;
  1248. +         char *newpath, *s;
  1249. +         Char **pv;
  1250. +         struct varent *v;
  1251. + 
  1252. +         newpath = s = alloca(strlen(path) + 5);
  1253. +         while (*path) {
  1254. +                 *s++ = *path++;
  1255. +         }
  1256. +         *s = 0;
  1257. + 
  1258. +         if (access(newpath, 0) == 0)
  1259. +                 return _spawnve(P_OVERLAY, newpath, argv, envp);
  1260. + 
  1261. +         v = adrof(STRsuffixes);
  1262. +         if (v == 0)
  1263. +                 return -1;
  1264. +         *s++ = '.';
  1265. + 
  1266. +         for (pv = v->vec; *pv; pv++) {
  1267. +                 strcpy(s, short2str(*pv));
  1268. +                 if (access(newpath, 0) == 0) {
  1269. +                         return _spawnve(P_OVERLAY, newpath, argv, envp);
  1270. +                 }
  1271. +         }
  1272. +         return -1;
  1273. + }
  1274. + #endif /* __MINT__ */
  1275. + 
  1276. diff --context --new-file --recursive ../tcsh-6.02/sh.file.c ./sh.file.c
  1277. *** ../tcsh-6.02/sh.file.c    Wed May 20 04:00:38 1992
  1278. --- ./sh.file.c    Sun Feb 21 01:38:56 1993
  1279. ***************
  1280. *** 407,413 ****
  1281.       if (old[0] != '~')
  1282.       return (Strcpy(new, old));
  1283.   
  1284. !     for (p = person, o = &old[1]; *o && *o != '/'; *p++ = *o++);
  1285.       *p = '\0';
  1286.       if (person[0] == '\0')
  1287.       (void) Strcpy(new, value(STRhome));
  1288. --- 407,413 ----
  1289.       if (old[0] != '~')
  1290.       return (Strcpy(new, old));
  1291.   
  1292. !     for (p = person, o = &old[1]; *o && (! is_dirsep(*o)); *p++ = *o++);
  1293.       *p = '\0';
  1294.       if (person[0] == '\0')
  1295.       (void) Strcpy(new, value(STRhome));
  1296. ***************
  1297. *** 502,508 ****
  1298.   {
  1299.       register Char *p;
  1300.   
  1301. !     p = Strrchr(path, '/');
  1302.       if (p == NULL) {
  1303.       copyn(name, path, MAXNAMLEN);
  1304.       dir[0] = '\0';
  1305. --- 502,508 ----
  1306.   {
  1307.       register Char *p;
  1308.   
  1309. !     p = Lastslash(path);
  1310.       if (p == NULL) {
  1311.       copyn(name, path, MAXNAMLEN);
  1312.       dir[0] = '\0';
  1313. ***************
  1314. *** 582,588 ****
  1315.       if (items != NULL)
  1316.       FREE_ITEMS(items);
  1317.   
  1318. !     looking_for_lognames = (*word == '~') && (Strchr(word, '/') == NULL);
  1319.       if (looking_for_lognames) {
  1320.       (void) setpwent();
  1321.       copyn(name, &word[1], MAXNAMLEN);    /* name sans ~ */
  1322. --- 582,588 ----
  1323.       if (items != NULL)
  1324.       FREE_ITEMS(items);
  1325.   
  1326. !     looking_for_lognames = (*word == '~') && (! Hasslash(word));
  1327.       if (looking_for_lognames) {
  1328.       (void) setpwent();
  1329.       copyn(name, &word[1], MAXNAMLEN);    /* name sans ~ */
  1330. diff --context --new-file --recursive ../tcsh-6.02/sh.func.c ./sh.func.c
  1331. *** ../tcsh-6.02/sh.func.c    Wed May 20 04:00:38 1992
  1332. --- ./sh.func.c    Sun Feb 21 01:38:58 1993
  1333. ***************
  1334. *** 66,71 ****
  1335. --- 66,75 ----
  1336.   static    void    toend        __P((void));
  1337.   static    void    xecho        __P((int, Char **));
  1338.   
  1339. + #ifdef __MINT__
  1340. + extern    void    importsuffixes    __P((Char *));  /* in sh.c */
  1341. + #endif
  1342. + 
  1343.   struct biltins *
  1344.   isbfunc(t)
  1345.       struct command *t;
  1346. ***************
  1347. *** 272,278 ****
  1348. --- 276,293 ----
  1349.       islogin();
  1350.       rechist();
  1351.       (void) signal(SIGTERM, parterm);
  1352. + #ifdef __MINT__
  1353. +     {
  1354. +         extern int csh_execve __P((char *, char **, char **)); /* in sh.exec.c */
  1355. +         extern char **environ;
  1356. +         char *args[3];
  1357. +         
  1358. +         args[0] = "login"; args[1] = short2str(v[1]); args[2] = NULL;
  1359. +         (void)csh_execve(_PATH_LOGIN, args, environ);
  1360. +     }
  1361. + #else
  1362.       (void) execl(_PATH_LOGIN, "login", short2str(v[1]), NULL);
  1363. + #endif
  1364.       untty();
  1365.       xexit(1);
  1366.   }
  1367. ***************
  1368. *** 1162,1167 ****
  1369. --- 1177,1188 ----
  1370.       importpath(lp);
  1371.       dohash(NULL, NULL);
  1372.       }
  1373. + #ifdef __MINT__
  1374. +     else if (eq(vp, STRSUFFIXES)) {
  1375. +         importsuffixes(lp);
  1376. +         dohash(NULL, NULL);
  1377. +     }
  1378. + #endif /* __MINT__ */
  1379.   #ifdef apollo
  1380.       else if (eq(vp, STRSYSTYPE))
  1381.       dohash(NULL, NULL);
  1382. ***************
  1383. *** 1256,1261 ****
  1384. --- 1277,1286 ----
  1385.           maxi = 1;
  1386.           if (eq(name, STRNOREBIND))
  1387.               NoNLSRebind = 0;
  1388. + #ifdef __MINT__
  1389. +                 else if (eq(name, STRSUFFIXES))
  1390. +                     dohash(NULL, NULL);
  1391. + #endif
  1392.   #ifdef apollo
  1393.           else if (eq(name, STRSYSTYPE))
  1394.               dohash(NULL, NULL);
  1395. diff --context --new-file --recursive ../tcsh-6.02/sh.glob.c ./sh.glob.c
  1396. *** ../tcsh-6.02/sh.glob.c    Wed May 20 04:00:40 1992
  1397. --- ./sh.glob.c    Sun Feb 21 01:38:58 1993
  1398. ***************
  1399. *** 97,103 ****
  1400.       *gstart++ = *s++;
  1401.       u = s;
  1402.       for (b = gstart, e = &gbuf[MAXPATHLEN - 1]; 
  1403. !      *s && *s != '/' && *s != ':' && b < e;
  1404.        *b++ = *s++)
  1405.       continue;
  1406.       *b = EOS;
  1407. --- 97,103 ----
  1408.       *gstart++ = *s++;
  1409.       u = s;
  1410.       for (b = gstart, e = &gbuf[MAXPATHLEN - 1]; 
  1411. !      *s && (! is_dirsep(*s)) && *s != ':' && b < e;
  1412.        *b++ = *s++)
  1413.       continue;
  1414.       *b = EOS;
  1415. ***************
  1416. *** 135,141 ****
  1417.        * kfk - 17 Jan 1984 - stack hack allows user to get at arbitrary dir names
  1418.        * in stack. PWP: let =foobar pass through (for X windows)
  1419.        */
  1420. !     if (old[1] == '-' && (old[2] == '\0' || old[2] == '/')) {
  1421.       /* =- */
  1422.       dig = -1;
  1423.       b = &old[2];
  1424. --- 135,141 ----
  1425.        * kfk - 17 Jan 1984 - stack hack allows user to get at arbitrary dir names
  1426.        * in stack. PWP: let =foobar pass through (for X windows)
  1427.        */
  1428. !     if (old[1] == '-' && (old[2] == '\0' || is_dirsep(old[2]))) {
  1429.       /* =- */
  1430.       dig = -1;
  1431.       b = &old[2];
  1432. ***************
  1433. *** 145,151 ****
  1434.       dig = old[1] - '0';
  1435.       for (b = &old[2]; Isdigit(*b); b++)
  1436.           dig = dig * 10 + (*b - '0');
  1437. !     if (*b != '\0' && *b != '/')
  1438.           /* =<number>foobar */
  1439.           return old;
  1440.       }
  1441. --- 145,151 ----
  1442.       dig = old[1] - '0';
  1443.       for (b = &old[2]; Isdigit(*b); b++)
  1444.           dig = dig * 10 + (*b - '0');
  1445. !     if (*b != '\0' && (! is_dirsep(*b)))
  1446.           /* =<number>foobar */
  1447.           return old;
  1448.       }
  1449. ***************
  1450. *** 665,671 ****
  1451.           else if (isglob(*c))
  1452.           gflag |= G_GLOB;
  1453.           else if (symlinks == SYM_EXPAND && 
  1454. !         *p && ISDOTDOT(c) && (c == *(t-1) || *(c-1) == '/') )
  1455.               gflag |= G_CSH;
  1456.       }
  1457.       }
  1458. --- 665,671 ----
  1459.           else if (isglob(*c))
  1460.           gflag |= G_GLOB;
  1461.           else if (symlinks == SYM_EXPAND && 
  1462. !         *p && ISDOTDOT(c) && (c == *(t-1) || is_dirsep(*(c-1))))
  1463.               gflag |= G_CSH;
  1464.       }
  1465.       }
  1466. ***************
  1467. *** 836,841 ****
  1468. --- 836,857 ----
  1469.           do
  1470.               icnt = read(pvec[0], tibuf, BUFSIZE);
  1471.           while (icnt == -1 && errno == EINTR);
  1472. + #ifdef DOSTEXT
  1473. +         /* strip out carriage returns */
  1474. +                 {
  1475. +                     char *src, *dst;
  1476. +                     int i;
  1477. +                     src = dst = tibuf;
  1478. + 
  1479. +                     for (i = icnt; i > 0; --i) {
  1480. +                             if (*src == '\r')
  1481. +                                     --icnt;
  1482. +                             else
  1483. +                                     *dst++ = *src;
  1484. +                             src++;
  1485. +                     }
  1486. +                 }
  1487. + #endif
  1488.           if (icnt <= 0) {
  1489.               c = -1;
  1490.               break;
  1491. diff --context --new-file --recursive ../tcsh-6.02/sh.h ./sh.h
  1492. *** ../tcsh-6.02/sh.h    Wed May 20 04:00:42 1992
  1493. --- ./sh.h    Sun Feb 21 01:39:08 1993
  1494. ***************
  1495. *** 160,166 ****
  1496.   #ifdef _SEQUENT_
  1497.   # include <sys/procstats.h>
  1498.   #endif /* _SEQUENT_ */
  1499. ! #if defined(POSIX) || SYSVREL > 0
  1500.   # include <sys/times.h>
  1501.   #endif /* POSIX || SYSVREL > 0 */
  1502.   
  1503. --- 160,166 ----
  1504.   #ifdef _SEQUENT_
  1505.   # include <sys/procstats.h>
  1506.   #endif /* _SEQUENT_ */
  1507. ! #if defined(POSIX) || SYSVREL > 0 || defined(__MINT__)
  1508.   # include <sys/times.h>
  1509.   #endif /* POSIX || SYSVREL > 0 */
  1510.   
  1511. ***************
  1512. *** 173,178 ****
  1513. --- 173,182 ----
  1514.   #endif /* _MINIX */
  1515.   #include <sys/stat.h>
  1516.   
  1517. + #ifdef __MINT__
  1518. + #include <support.h>
  1519. + #endif
  1520. + 
  1521.   #ifdef BSDTIMES
  1522.   # include <sys/time.h>
  1523.   # if SYSVREL>3
  1524. ***************
  1525. *** 202,208 ****
  1526.   #  define CSWTCH _POSIX_VDISABLE    /* So job control works */
  1527.   #endif /* DGUX */
  1528.   
  1529. ! #ifdef POSIX
  1530.   /*
  1531.    * We should be using setpgid and setpgid
  1532.    * by now, but in some systems we use the
  1533. --- 206,212 ----
  1534.   #  define CSWTCH _POSIX_VDISABLE    /* So job control works */
  1535.   #endif /* DGUX */
  1536.   
  1537. ! #if defined(POSIX) || defined(__MINT__)
  1538.   /*
  1539.    * We should be using setpgid and setpgid
  1540.    * by now, but in some systems we use the
  1541. ***************
  1542. *** 261,266 ****
  1543. --- 265,277 ----
  1544.   
  1545.   #include <errno.h>
  1546.   
  1547. + #ifdef __MINT__
  1548. + /* undef E_SEEK from errno.h */
  1549. + # undef E_SEEK
  1550. + # define ENOTDIR EPATH
  1551. + # define ESPIPE EINVAL
  1552. + #endif
  1553. + 
  1554.   #include <setjmp.h>
  1555.   
  1556.   #if __STDC__
  1557. ***************
  1558. *** 318,323 ****
  1559. --- 329,349 ----
  1560.   # endif 
  1561.   #endif 
  1562.   
  1563. + #ifndef DOSFS
  1564. + # define is_dirsep(c)    ((c) == '/')
  1565. + # define is_abspath(p)    (is_dirsep(*(p)))
  1566. + # define lastslash(p)    (strrchr((p), '/'))
  1567. + # define Lastslash(p)    (Strrchr((p), '/'))
  1568. + # define hasslash(p)    (any((p), '/'))
  1569. + # define Hasslash(p)    (Strrchr((p), '/'))
  1570. + #else
  1571. + extern int    is_dirsep    __P((int));
  1572. + extern int    is_abspath    __P((Char *));
  1573. + extern char *    lastslash    __P((char *));
  1574. + extern Char *    Lastslash    __P((Char *));
  1575. + extern int    hasslash    __P((char *));
  1576. + extern int    Hasslash    __P((Char *));
  1577. + #endif
  1578.   
  1579.   typedef int bool;
  1580.   
  1581. diff --context --new-file --recursive ../tcsh-6.02/sh.lex.c ./sh.lex.c
  1582. *** ../tcsh-6.02/sh.lex.c    Wed May 20 04:00:40 1992
  1583. --- ./sh.lex.c    Sun Feb 21 01:39:02 1993
  1584. ***************
  1585. *** 387,393 ****
  1586.       for (;;) {
  1587.       if ((c = peekc) != 0) {
  1588.           peekc = 0;
  1589. !         return (c);
  1590.       }
  1591.       if (lap) {
  1592.           if ((c = *lap++) == 0)
  1593. --- 387,393 ----
  1594.       for (;;) {
  1595.       if ((c = peekc) != 0) {
  1596.           peekc = 0;
  1597. !             goto ret_c;
  1598.       }
  1599.       if (lap) {
  1600.           if ((c = *lap++) == 0)
  1601. ***************
  1602. *** 395,410 ****
  1603.           else {
  1604.           if (cmap(c, _META | _Q | _Q1))
  1605.               c |= QUOTE;
  1606. !         return (c);
  1607.           }
  1608.       }
  1609.       if ((c = peekd) != 0) {
  1610.           peekd = 0;
  1611. !         return (c);
  1612.       }
  1613.       if (exclp) {
  1614.           if ((c = *exclp++) != 0)
  1615. !         return (c);
  1616.           if (exclnxt && --exclc >= 0) {
  1617.           exclnxt = exclnxt->next;
  1618.           setexclp(exclnxt->word);
  1619. --- 395,410 ----
  1620.           else {
  1621.           if (cmap(c, _META | _Q | _Q1))
  1622.               c |= QUOTE;
  1623. !         goto ret_c;
  1624.           }
  1625.       }
  1626.       if ((c = peekd) != 0) {
  1627.           peekd = 0;
  1628. !         goto ret_c;
  1629.       }
  1630.       if (exclp) {
  1631.           if ((c = *exclp++) != 0)
  1632. !         goto ret_c;
  1633.           if (exclnxt && --exclc >= 0) {
  1634.           exclnxt = exclnxt->next;
  1635.           setexclp(exclnxt->word);
  1636. ***************
  1637. *** 433,438 ****
  1638. --- 433,445 ----
  1639.       break;
  1640.       }
  1641.       return (c);
  1642. + 
  1643. + ret_c:
  1644. + #ifdef DOSTEXT
  1645. +     return (c == '\r' ? getC1(flag) : c);
  1646. + #else
  1647. +     return (c);
  1648. + #endif
  1649.   }
  1650.   
  1651.   static void
  1652. ***************
  1653. *** 1060,1069 ****
  1654.   
  1655.       case 'h':
  1656.       case 't':
  1657. !     if (!any(short2str(cp), '/'))
  1658.           return (type == 't' ? Strsave(cp) : 0);
  1659.       wp = Strend(cp);
  1660. !     while (*--wp != '/')
  1661.           continue;
  1662.       if (type == 'h')
  1663.           xp = Strsave(cp), xp[wp - cp] = 0;
  1664. --- 1067,1076 ----
  1665.   
  1666.       case 'h':
  1667.       case 't':
  1668. !     if (! hasslash(short2str(cp)))
  1669.           return (type == 't' ? Strsave(cp) : 0);
  1670.       wp = Strend(cp);
  1671. !     while (! is_dirsep(*--wp))
  1672.           continue;
  1673.       if (type == 'h')
  1674.           xp = Strsave(cp), xp[wp - cp] = 0;
  1675. ***************
  1676. *** 1074,1080 ****
  1677.       case 'e':
  1678.       case 'r':
  1679.       wp = Strend(cp);
  1680. !     for (wp--; wp >= cp && *wp != '/'; wp--)
  1681.           if (*wp == '.') {
  1682.           if (type == 'e')
  1683.               xp = Strsave(wp + 1);
  1684. --- 1081,1087 ----
  1685.       case 'e':
  1686.       case 'r':
  1687.       wp = Strend(cp);
  1688. !     for (wp--; wp >= cp && (! is_dirsep(*wp)); wp--)
  1689.           if (*wp == '.') {
  1690.           if (type == 'e')
  1691.               xp = Strsave(wp + 1);
  1692. ***************
  1693. *** 1554,1560 ****
  1694.       }
  1695.       c = fbuf[0][fseekp - fbobp];
  1696.       fseekp++;
  1697. !     return (c);
  1698.       }
  1699.   again:
  1700.       buf = (int) fseekp / BUFSIZE;
  1701. --- 1561,1567 ----
  1702.       }
  1703.       c = fbuf[0][fseekp - fbobp];
  1704.       fseekp++;
  1705. !     goto ret_c;
  1706.       }
  1707.   again:
  1708.       buf = (int) fseekp / BUFSIZE;
  1709. ***************
  1710. *** 1646,1652 ****
  1711. --- 1653,1665 ----
  1712.       }
  1713.       c = fbuf[buf][(int) fseekp % BUFSIZE];
  1714.       fseekp++;
  1715. + 
  1716. + ret_c:
  1717. + #ifdef DOSTEXT
  1718. +     return (c == '\r' ? bgetc() : c);
  1719. + #else
  1720.       return (c);
  1721. + #endif
  1722.   }
  1723.   
  1724.   static void
  1725. diff --context --new-file --recursive ../tcsh-6.02/sh.misc.c ./sh.misc.c
  1726. *** ../tcsh-6.02/sh.misc.c    Wed May 20 04:00:40 1992
  1727. --- ./sh.misc.c    Sun Feb 21 01:39:02 1993
  1728. ***************
  1729. *** 38,43 ****
  1730. --- 38,47 ----
  1731.   
  1732.   RCSID("$Id: sh.misc.c,v 3.12 1992/03/27 01:59:46 christos Exp $")
  1733.   
  1734. + #ifdef __MINT__
  1735. + extern int __mint;      /* kernel version */
  1736. + #endif
  1737. + 
  1738.   static    int    renum    __P((int, int));
  1739.   static  Char  **blkend    __P((Char **));
  1740.   static  Char  **blkcat    __P((Char **, Char **));
  1741. ***************
  1742. *** 266,271 ****
  1743. --- 270,281 ----
  1744.   {
  1745.       register int f;
  1746.   
  1747. + #ifdef __MINT__
  1748. + /* in TOS, all handles are shared by all processes! (ack!) */
  1749. +     if (__mint == 0)
  1750. +         return;
  1751. + #endif
  1752. + 
  1753.       if (didcch)
  1754.       return;
  1755.       didcch = 1;
  1756. ***************
  1757. *** 304,309 ****
  1758. --- 314,322 ----
  1759.       if (i == j || i < 0)
  1760.       return (i);
  1761.   #ifdef HAVEDUP2
  1762. + # ifdef __MINT__
  1763. +     if (__mint != 0)    /* TOS screws up dup2 */
  1764. + # endif
  1765.       if (j >= 0) {
  1766.       (void) dup2(i, j);
  1767.       if (j != i)
  1768. ***************
  1769. *** 324,329 ****
  1770. --- 337,347 ----
  1771.   
  1772.       if (i == j || i < 0 || (j < 0 && i > 2))
  1773.       return (i);
  1774. + #ifdef __MINT__
  1775. +     if (__mint == 0 && j > 5) {
  1776. +         return (i <= 5) ? dup(i) : j;
  1777. +     }
  1778. + #endif
  1779.   #ifdef HAVEDUP2
  1780.       if (j >= 0) {
  1781.       (void) dup2(i, j);
  1782. ***************
  1783. *** 458,460 ****
  1784. --- 476,561 ----
  1785.           return (0);
  1786.       }
  1787.   }
  1788. + 
  1789. + #ifdef DOSFS
  1790. + 
  1791. + int
  1792. + is_dirsep(i)
  1793. +     int i;
  1794. + {
  1795. +     return i == '/' || i == '\\' ;
  1796. + }
  1797. + 
  1798. + int
  1799. + is_abspath(pth)
  1800. +     register Char *pth;
  1801. + {
  1802. +     return is_dirsep(TRM(*pth)) || TRM(pth[1]) == ':';
  1803. + }
  1804. + 
  1805. + char *
  1806. + lastslash(pth)
  1807. +         register char *pth;
  1808. + {
  1809. +         register char *slash = 0, *s = pth, c;
  1810. + 
  1811. +         if (! s) return 0;
  1812. + 
  1813. +         while ( (c = *s++) != 0) {
  1814. +                 if (is_dirsep(c))
  1815. +                         slash = s - 1;
  1816. +         }
  1817. +         if (slash)
  1818. +                 return slash;
  1819. +         return (pth[1] == ':') ? pth : 0;
  1820. + }
  1821. + 
  1822. + Char *
  1823. + Lastslash(pth)
  1824. +     register Char *pth;
  1825. + {
  1826. +         register Char *slash = 0, *s = pth, c;
  1827. + 
  1828. +     if (! s) return 0;
  1829. + 
  1830. +         while ( (c = *s++) != 0) {
  1831. +                 if (is_dirsep(c))
  1832. +                         slash = s - 1;
  1833. +         }
  1834. +     if (slash)
  1835. +         return slash;
  1836. +     return (pth[1] == ':') ? pth : 0;
  1837. + }
  1838. + 
  1839. + int
  1840. + hasslash(pth)
  1841. +         register char *pth;
  1842. + {
  1843. +         register char c;
  1844. + 
  1845. +         if (! pth) return 0;
  1846. + 
  1847. +         while ( (c = *pth++) != 0)
  1848. +                 if (is_dirsep(c))
  1849. +                         return 1;
  1850. + 
  1851. +         return 0;
  1852. + }
  1853. + 
  1854. + int
  1855. + Hasslash(pth)
  1856. +     register Char *pth;
  1857. + {
  1858. +     register Char c;
  1859. + 
  1860. +     if (! pth) return 0;
  1861. + 
  1862. +     while ( (c = *pth++) != 0)
  1863. +         if (is_dirsep(c))
  1864. +             return 1;
  1865. + 
  1866. +     return 0;
  1867. + }
  1868. + 
  1869. + #endif /* DOSFS */
  1870. + 
  1871. diff --context --new-file --recursive ../tcsh-6.02/sh.proc.c ./sh.proc.c
  1872. *** ../tcsh-6.02/sh.proc.c    Wed May 20 04:00:40 1992
  1873. --- ./sh.proc.c    Sun Feb 21 01:39:04 1993
  1874. ***************
  1875. *** 83,94 ****
  1876.                   0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L};
  1877.   
  1878.   # else /* !sun && !hp9000 */
  1879. ! #  ifdef masscomp
  1880.   /*
  1881.    * Initialization of this structure under RTU 4.1A & RTU 5.0 is problematic
  1882.    * because the first two elements are unions of a time_t and a struct timeval.
  1883.    * So we'll just have to trust the loader to do the "right thing", DAS DEC-90.
  1884.    */
  1885.   static struct rusage zru;
  1886.   #  else    /* masscomp */
  1887.   static struct rusage zru = {{0L, 0L}, {0L, 0L}, 0, 0, 0, 0, 0, 0, 0, 
  1888. --- 83,97 ----
  1889.                   0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L};
  1890.   
  1891.   # else /* !sun && !hp9000 */
  1892. ! #  if defined(masscomp) || defined(__MINT__)
  1893.   /*
  1894.    * Initialization of this structure under RTU 4.1A & RTU 5.0 is problematic
  1895.    * because the first two elements are unions of a time_t and a struct timeval.
  1896.    * So we'll just have to trust the loader to do the "right thing", DAS DEC-90.
  1897.    */
  1898. + /* MiNT is missing a lot of fields, so we also trust the loader (we can
  1899. +  * trust it) to avoid getting errors from the compiler
  1900. +  */
  1901.   static struct rusage zru;
  1902.   #  else    /* masscomp */
  1903.   static struct rusage zru = {{0L, 0L}, {0L, 0L}, 0, 0, 0, 0, 0, 0, 0, 
  1904. ***************
  1905. *** 120,125 ****
  1906. --- 123,146 ----
  1907.   static    void         okpcntl    __P((void));
  1908.   static  struct process  *pfind        __P((Char *));
  1909.   
  1910. + #ifdef __MINT__
  1911. + /*
  1912. +  * MiNT's fork() is a lot like vfork() in some respects; in particular,
  1913. +  * if we set job control signals to SIG_DFL after fork() and then
  1914. +  * get a signal, our parent will never be able to reclaim the address
  1915. +  * space and everything will hang :-(. Solution: rather than SIG_DFL,
  1916. +  * set the signals to a null signal handler; if we exec(), they will
  1917. +  * be set to SIG_DFL automatically, and before then the signals will
  1918. +  * effectively be ignored.
  1919. +  */
  1920. + 
  1921. + void
  1922. + sig_tmp_ign(int sig)
  1923. + {
  1924. + /* do nothing, and rely on the magic of restartable system calls :-) */
  1925. + }
  1926. + #endif
  1927. + 
  1928.   /*
  1929.    * pchild - called at interrupt level by the SIGCHLD signal
  1930.    *    indicating that at least one child has terminated or stopped
  1931. ***************
  1932. *** 1826,1835 ****
  1933. --- 1847,1863 ----
  1934.           (void) signal(SIGQUIT, ignint ? SIG_IGN : SIG_DFL);
  1935.   #ifdef BSDJOBS
  1936.           if (wanttty >= 0) {
  1937. + # ifdef __MINT__
  1938. + /* see comments for sig_tmp_ign above */
  1939. +                 (void) signal(SIGTSTP, sig_tmp_ign);
  1940. +                 (void) signal(SIGTTIN, sig_tmp_ign);
  1941. +                 (void) signal(SIGTTOU, sig_tmp_ign);
  1942. + # else
  1943.           /* make stoppable */
  1944.           (void) signal(SIGTSTP, SIG_DFL);
  1945.           (void) signal(SIGTTIN, SIG_DFL);
  1946.           (void) signal(SIGTTOU, SIG_DFL);
  1947. + # endif
  1948.           }
  1949.   #endif /* BSDJOBS */
  1950.           (void) signal(SIGTERM, parterm);
  1951. diff --context --new-file --recursive ../tcsh-6.02/sh.sem.c ./sh.sem.c
  1952. *** ../tcsh-6.02/sh.sem.c    Wed May 20 04:00:42 1992
  1953. --- ./sh.sem.c    Sun Feb 21 01:39:06 1993
  1954. ***************
  1955. *** 490,498 ****
  1956. --- 490,507 ----
  1957.               }
  1958.   # ifdef BSDJOBS
  1959.               if (_gv.wanttty >= 0) {
  1960. + #  ifdef __MINT__
  1961. + /* see sh.proc.c */
  1962. +                             extern void sig_tmp_ign();
  1963. + 
  1964. +                             (void) signal(SIGTSTP, sig_tmp_ign);
  1965. +                             (void) signal(SIGTTIN, sig_tmp_ign);
  1966. +                             (void) signal(SIGTTOU, sig_tmp_ign);
  1967. + #  else
  1968.                   (void) signal(SIGTSTP, SIG_DFL);
  1969.                   (void) signal(SIGTTIN, SIG_DFL);
  1970.                   (void) signal(SIGTTOU, SIG_DFL);
  1971. + #  endif
  1972.               }
  1973.   # endif /* BSDJOBS */
  1974.   
  1975. ***************
  1976. *** 624,631 ****
  1977. --- 633,642 ----
  1978.       execute(t->t_dcdr, _gv.wanttty, pv, pipeout);
  1979.       t->t_dcar->t_dflg |= F_PIPEOUT |
  1980.           (t->t_dflg & (F_PIPEIN | F_AMPERSAND | F_STDERR | F_NOINTERRUPT));
  1981. + # ifndef __MINT__
  1982.       if (_gv.wanttty > 0)
  1983.           _gv.wanttty = 0;    /* got tty already */
  1984. + # endif
  1985.       execute(t->t_dcar, _gv.wanttty, pipein, pv);
  1986.   #else /* !BACKPIPE */
  1987.       t->t_dcar->t_dflg |= F_PIPEOUT |
  1988. ***************
  1989. *** 633,640 ****
  1990. --- 644,653 ----
  1991.       execute(t->t_dcar, _gv.wanttty, pipein, pv);
  1992.       t->t_dcdr->t_dflg |= F_PIPEIN | (t->t_dflg &
  1993.               (F_PIPEOUT | F_AMPERSAND | F_NOFORK | F_NOINTERRUPT));
  1994. + # ifndef __MINT__
  1995.       if (_gv.wanttty > 0)
  1996.           _gv.wanttty = 0;    /* got tty already */
  1997. + # endif
  1998.       execute(t->t_dcdr, _gv.wanttty, pv, pipeout);
  1999.   #endif /* BACKPIPE */
  2000.       break;
  2001. ***************
  2002. *** 803,820 ****
  2003. --- 816,847 ----
  2004.           (void) dmove(fd, 0);
  2005.       }
  2006.       else if (flags & F_PIPEIN) {
  2007. + #ifdef __MINT__
  2008. +             (void) dup2(pipein[0], 0);
  2009. + #else
  2010.           (void) close(0);
  2011.           (void) dup(pipein[0]);
  2012. + #endif
  2013.           (void) close(pipein[0]);
  2014.           (void) close(pipein[1]);
  2015.       }
  2016.       else if ((flags & F_NOINTERRUPT) && tpgrp == -1) {
  2017. + #ifdef __MINT__
  2018. +             int fd = open(_PATH_DEVNULL, O_RDONLY);
  2019. +             (void) dup2(fd, 0);
  2020. +             (void) close(fd);
  2021. + #else
  2022.           (void) close(0);
  2023.           (void) open(_PATH_DEVNULL, O_RDONLY);
  2024. + #endif
  2025.       }
  2026.       else {
  2027. + #ifdef __MINT__
  2028. +             (void) dup2(OLDSTD, 0);
  2029. + #else
  2030.           (void) close(0);
  2031.           (void) dup(OLDSTD);
  2032. + #endif
  2033.   #ifdef FIONCLEX
  2034.   # ifdef CLEX_DUPS
  2035.           /*
  2036. ***************
  2037. *** 863,875 ****
  2038. --- 890,910 ----
  2039.       is1atty = isatty(1);
  2040.       }
  2041.       else if (flags & F_PIPEOUT) {
  2042. + #ifdef __MINT__
  2043. +         (void) dup2(pipeout[1], 1);
  2044. + #else
  2045.       (void) close(1);
  2046.       (void) dup(pipeout[1]);
  2047. + #endif
  2048.       is1atty = 0;
  2049.       }
  2050.       else {
  2051. + #ifdef __MINT__
  2052. +         (void) dup2(SHOUT, 1);
  2053. + #else
  2054.       (void) close(1);
  2055.       (void) dup(SHOUT);
  2056. + #endif
  2057.       is1atty = isoutatty;
  2058.   #ifdef FIONCLEX
  2059.   # ifdef CLEX_DUPS
  2060. ***************
  2061. *** 880,890 ****
  2062. --- 915,933 ----
  2063.   
  2064.       (void) close(2);
  2065.       if (flags & F_STDERR) {
  2066. + #ifdef __MINT__
  2067. +         (void) dup2(1, 2);
  2068. + #else
  2069.       (void) dup(1);
  2070. + #endif
  2071.       is2atty = is1atty;
  2072.       }
  2073.       else {
  2074. + #ifdef __MINT__
  2075. +         (void) dup2(SHDIAG, 2);
  2076. + #else
  2077.       (void) dup(SHDIAG);
  2078. + #endif
  2079.       is2atty = isdiagatty;
  2080.   #ifdef FIONCLEX
  2081.   # ifdef CLEX_DUPS
  2082. diff --context --new-file --recursive ../tcsh-6.02/sh.set.c ./sh.set.c
  2083. *** ../tcsh-6.02/sh.set.c    Wed May 20 04:00:42 1992
  2084. --- ./sh.set.c    Sun Feb 21 01:39:06 1993
  2085. ***************
  2086. *** 53,58 ****
  2087. --- 53,61 ----
  2088.   static    struct varent    *madrof        __P((Char *, struct varent *));
  2089.   static    void         unsetv1    __P((struct varent *));
  2090.   static    void         exportpath    __P((Char **));
  2091. + #ifdef __MINT__
  2092. + static  void             exportsuffixes __P((Char **));
  2093. + #endif
  2094.   static    void         balance    __P((struct varent *, int, int));
  2095.   
  2096.   /*
  2097. ***************
  2098. *** 132,137 ****
  2099. --- 135,146 ----
  2100.           exportpath(adrof(STRpath)->vec);
  2101.           dohash(NULL, NULL);
  2102.       }
  2103. + #ifdef __MINT__
  2104. +         else if (eq(vp, STRsuffixes)) {
  2105. +             exportsuffixes(adrof(STRsuffixes)->vec);
  2106. +             dohash(NULL, NULL);
  2107. +         }
  2108. + #endif
  2109.       else if (eq(vp, STRhistchars)) {
  2110.           register Char *pn = value(vp);
  2111.   
  2112. ***************
  2113. *** 335,340 ****
  2114. --- 344,355 ----
  2115.           exportpath(adrof(STRpath)->vec);
  2116.           dohash(NULL, NULL);
  2117.       }
  2118. + #ifdef __MINT__
  2119. +         else if (eq(vp, STRsuffixes)) {
  2120. +             exportsuffixes(adrof(STRsuffixes)->vec);
  2121. +             dohash(NULL, NULL);
  2122. +         }
  2123. + #endif
  2124.       xfree((ptr_t) vp);
  2125.       if (c != '=')
  2126.           xfree((ptr_t) p);
  2127. ***************
  2128. *** 407,413 ****
  2129.       }
  2130.       else {
  2131.       num = 4;        /* confuse lint */
  2132. !     if (sizeof(int) == num && ((unsigned int) n) == 2147483648) {
  2133.           *putp++ = '2';
  2134.           n = 147483648;
  2135.       }
  2136. --- 422,428 ----
  2137.       }
  2138.       else {
  2139.       num = 4;        /* confuse lint */
  2140. !     if (sizeof(int) == num && ((unsigned int) n) == 2147483648U) {
  2141.           *putp++ = '2';
  2142.           n = 147483648;
  2143.       }
  2144. ***************
  2145. *** 717,722 ****
  2146. --- 732,761 ----
  2147.       Setenv(STRPATH, exppath);
  2148.   }
  2149.   
  2150. + #ifdef __MINT__
  2151. + static void
  2152. + exportsuffixes(val)
  2153. +     Char  **val;
  2154. + {
  2155. +     Char    expsuff[BUFSIZE];
  2156. +     static Char STRcomma[] = { ',' , '\0' };
  2157. + 
  2158. +     expsuff[0] = 0;
  2159. +     if (val)
  2160. +         while (*val) {
  2161. +             if (Strlen(*val) + Strlen(expsuff) + 2 > BUFSIZE) {
  2162. +                 xprintf("Warning: ridiculously long SUFFIXES truncated\n");
  2163. +                 break;
  2164. +             }
  2165. +             (void) Strcat(expsuff, *val++);
  2166. +             if (*val == 0 || eq(*val, STRRparen))
  2167. +                 break;
  2168. +             (void) Strcat(expsuff, STRcomma);
  2169. +         }
  2170. +     Setenv(STRSUFFIXES, expsuff);
  2171. + }
  2172. + #endif /* __MINT__ */
  2173. + 
  2174.   #ifndef lint
  2175.    /*
  2176.     * Lint thinks these have null effect
  2177. diff --context --new-file --recursive ../tcsh-6.02/sh.time.c ./sh.time.c
  2178. *** ../tcsh-6.02/sh.time.c    Wed May 20 04:00:42 1992
  2179. --- ./sh.time.c    Sun Feb 21 01:39:06 1993
  2180. ***************
  2181. *** 168,173 ****
  2182. --- 168,174 ----
  2183.   {
  2184.       tvadd(&ru->ru_utime, &ru2->ru_utime);
  2185.       tvadd(&ru->ru_stime, &ru2->ru_stime);
  2186. + #ifndef __MINT__
  2187.       if (ru2->ru_maxrss > ru->ru_maxrss)
  2188.       ru->ru_maxrss = ru2->ru_maxrss;
  2189.   
  2190. ***************
  2191. *** 184,189 ****
  2192. --- 185,191 ----
  2193.       ru->ru_nsignals += ru2->ru_nsignals;
  2194.       ru->ru_nvcsw += ru2->ru_nvcsw;
  2195.       ru->ru_nivcsw += ru2->ru_nivcsw;
  2196. + #endif
  2197.   }
  2198.   
  2199.   #else /* BSDTIMES */
  2200. ***************
  2201. *** 313,319 ****
  2202. --- 315,325 ----
  2203.       int     ms =
  2204.       (e->tv_sec - b->tv_sec) * 100 + (e->tv_usec - b->tv_usec) / 10000;
  2205.   
  2206. + # ifdef __MINT__
  2207. +     cp = "%Uu %Ss %E %P";
  2208. + # else
  2209.       cp = "%Uu %Ss %E %P %X+%Dk %I+%Oio %Fpf+%Ww";
  2210. + # endif
  2211.   #else
  2212.   # ifdef _SEQUENT_
  2213.       int     ms =
  2214. ***************
  2215. *** 404,410 ****
  2216.           xprintf("%ld.%01ld%%", i / 10, i % 10);    /* nn.n% */
  2217.           break;
  2218.   
  2219. ! #ifdef BSDTIMES
  2220.           case 'W':        /* number of swaps */
  2221.           i = r1->ru_nswap - r0->ru_nswap;
  2222.           xprintf("%ld", i);
  2223. --- 410,416 ----
  2224.           xprintf("%ld.%01ld%%", i / 10, i % 10);    /* nn.n% */
  2225.           break;
  2226.   
  2227. ! #if defined(BSDTIMES) && !defined(__MINT__)
  2228.           case 'W':        /* number of swaps */
  2229.           i = r1->ru_nswap - r0->ru_nswap;
  2230.           xprintf("%ld", i);
  2231. diff --context --new-file --recursive ../tcsh-6.02/sh.types.h ./sh.types.h
  2232. *** ../tcsh-6.02/sh.types.h    Wed May 20 04:00:50 1992
  2233. --- ./sh.types.h    Sun Feb 21 01:39:38 1993
  2234. ***************
  2235. *** 402,407 ****
  2236. --- 402,416 ----
  2237.   # endif /* __SIZE_T && !_SIZE_T */
  2238.   #endif /* convex || __convex__ */
  2239.   
  2240. + /*
  2241. +  * MiNT
  2242. +  */
  2243. + #ifdef __MINT__
  2244. + # define _SIGMASK_T
  2245. + typedef long sigmask_t;
  2246. + #endif
  2247. + 
  2248. + 
  2249.   /***
  2250.    *** Catch all for non POSIX and/or non ANSI systems.
  2251.    *** Systems up to spec *should* define these automatically
  2252. diff --context --new-file --recursive ../tcsh-6.02/tc.alloc.c ./tc.alloc.c
  2253. *** ../tcsh-6.02/tc.alloc.c    Wed May 20 04:00:48 1992
  2254. --- ./tc.alloc.c    Sun Feb 21 01:39:30 1993
  2255. ***************
  2256. *** 46,51 ****
  2257. --- 46,58 ----
  2258.   
  2259.   RCSID("$Id: tc.alloc.c,v 3.12 1992/05/02 23:39:58 christos Exp $")
  2260.   
  2261. + #ifdef __MINT__
  2262. + /* need large stack because we alloc from stack (cause tcsh assumes
  2263. +  * continuus memory which MiNT does not provide)
  2264. +  */
  2265. + long _stksize = -128*1024L;
  2266. + #endif
  2267. + 
  2268.   static char   *memtop = NULL;        /* PWP: top of current memory */
  2269.   static char   *membot = NULL;        /* PWP: bottom of allocatable memory */
  2270.   
  2271. ***************
  2272. *** 240,249 ****
  2273. --- 247,259 ----
  2274.       memtop = (char *) op;
  2275.       if (membot == NULL)
  2276.       membot = memtop;
  2277. + 
  2278. + #ifndef __MINT__
  2279.       if ((int) op & 0x3ff) {
  2280.       memtop = (char *) sbrk(1024 - ((int) op & 0x3ff));
  2281.       memtop += 1024 - ((int) op & 0x3ff);
  2282.       }
  2283. + #endif
  2284.   
  2285.       /* take 2k unless the block is bigger than that */
  2286.       rnu = (bucket <= 8) ? 11 : bucket + 3;
  2287. diff --context --new-file --recursive ../tcsh-6.02/tc.const.c ./tc.const.c
  2288. *** ../tcsh-6.02/tc.const.c    Wed May 20 04:00:48 1992
  2289. --- ./tc.const.c    Sun Feb 21 01:39:32 1993
  2290. ***************
  2291. *** 77,101 ****
  2292. --- 77,127 ----
  2293.   Char STRhistfile[]     = { 'h', 'i', 's', 't', 'f', 'i', 'l', 'e', '\0' };
  2294.   Char STRsource[]        = { 's', 'o', 'u', 'r', 'c', 'e', '\0' };
  2295.   Char STRmh[]            = { '-', 'h', '\0' };
  2296. + #ifndef DOSFS
  2297.   Char STRtildothist[]    = { '~', '/', '.', 'h', 'i', 's', 't', 'o', 'r', 
  2298.                       'y', '\0' };
  2299. + #else
  2300. + Char STRtildothist[]    = { '~', '/', 'h', 'i', 's', 't', 'o', 'r', 'y',
  2301. +                             '.', 'c', 's', 'h', '\0' };
  2302. + #endif
  2303.   
  2304.   #ifdef KANJI
  2305.   Char STRnokanji[]       = { 'n', 'o', 'k', 'a', 'n', 'j', 'i', '\0' };
  2306.   #endif
  2307.   
  2308.   #ifdef CSHDIRS
  2309. + # ifndef DOSFS
  2310.   Char STRdirfile[]     = { '~', '/', '.', 'c', 's', 'h', 'd', 'i', 'r',
  2311.                             's', '\0' };
  2312.   Char STRsldtdirs[]    = { '/', '.', 'c', 's', 'h', 'd', 'i', 'r', 's', '\0' };
  2313. + # else
  2314. + Char STRdirfile[]     = { '~', '/', 'c', 's', 'h', 'd', 'i', 'r', 's',
  2315. +                           '.', 'c', 's', 'h', '\0' };
  2316. + Char STRsldtdirs[]    = { '/', 'c', 's', 'h', 'd', 'i', 'r', 's', '.',
  2317. +                           'c', 's', 'h', '\0' };
  2318. + # endif
  2319.   Char STRsavedirs[]    = { 's', 'a', 'v', 'e', 'd', 'i', 'r', 's', '\0' };
  2320.   #endif
  2321.   
  2322.   Char STRargv[]          = { 'a', 'r', 'g', 'v', '\0' };
  2323.   Char STRsavehist[]      = { 's', 'a', 'v', 'e', 'h', 'i', 's', 't', '\0' };
  2324. + 
  2325. + #ifndef DOSFS
  2326.   Char STRsldthist[]      = { '/', '.', 'h', 'i', 's', 't', 'o', 'r', 'y', '\0' };
  2327. + #else
  2328. + Char STRsldthist[]      = { '/', 'h', 'i', 's', 't', 'o', 'r', 'y', '.',
  2329. +                             'c', 's', 'h', '\0' };
  2330. + #endif
  2331. + 
  2332.   Char STRnormal[]        = { 'n', 'o', 'r', 'm', 'a', 'l', '\0' };
  2333. + 
  2334. + #ifndef DOSFS
  2335.   Char STRsldtlogout[]    = { '/', '.', 'l', 'o', 'g', 'o', 'u', 't', '\0' };
  2336. + #else
  2337. + Char STRsldtlogout[]    = { '/', 'l', 'o', 'g', 'o', 'u', 't', '.', 'c', 's',
  2338. +                             'h', '\0' };
  2339. + #endif
  2340. + 
  2341.   Char STRjobs[]          = { 'j', 'o', 'b', 's', '\0' };
  2342.   Char STRsymhash[]       = { '#', ' ', '\0' };
  2343.   Char STRsymarrow[]      = { '>', ' ', '\0' };
  2344. ***************
  2345. *** 197,205 ****
  2346. --- 223,241 ----
  2347.   Char STRmail[]        = { 'm', 'a', 'i', 'l', '\0' };
  2348.   Char STRwatch[]        = { 'w', 'a', 't', 'c', 'h', '\0' };
  2349.   
  2350. + #ifndef DOSFS
  2351.   Char STRsldottcshrc[]    = { '/', '.', 't', 'c', 's', 'h', 'r', 'c', '\0' };
  2352.   Char STRsldotcshrc[]    = { '/', '.', 'c', 's', 'h', 'r', 'c', '\0' };
  2353.   Char STRsldotlogin[]    = { '/', '.', 'l', 'o', 'g', 'i', 'n', '\0' };
  2354. + #else
  2355. + Char STRsldottcshrc[]   = { '/', 't', 'c', 's', 'h', 'r', 'c', '.', 'c', 
  2356. +                             's', 'h', '\0' };
  2357. + Char STRsldotcshrc[]    = { '/', 'c', 's', 'h', 'r', 'c', '.', 'c', 's', 
  2358. +                             'h', '\0' };
  2359. + Char STRsldotlogin[]    = { '/', 'l', 'o', 'g', 'i', 'n', '.', 'c', 's',
  2360. +                             'h', '\0' };
  2361. + #endif
  2362. + 
  2363.   Char STRignoreeof[]    = { 'i', 'g', 'n', 'o', 'r', 'e', 'e', 'o', 'f', '\0' };
  2364.   Char STRnoclobber[]    = { 'n', 'o', 'c', 'l', 'o', 'b', 'b', 'e', 'r', '\0' };
  2365.   Char STRhelpcommand[]    = { 'h', 'e', 'l', 'p', 'c', 'o', 'm', 'm', 'a', 'n', 
  2366. ***************
  2367. *** 270,272 ****
  2368. --- 306,313 ----
  2369.   Char STRsys53[] = { 's', 'y', 's', '5', '.', '3', '\0' };
  2370.   Char STRver[] = { 'v', 'e', 'r', '\0' };
  2371.   #endif /* apollo */
  2372. + 
  2373. + #ifdef __MINT__
  2374. + Char STRsuffixes[] = { 's', 'u', 'f', 'f', 'i', 'x', 'e', 's', '\0' };
  2375. + Char STRSUFFIXES[] = { 'S', 'U', 'F', 'F', 'I', 'X', 'E', 'S', '\0' };
  2376. + #endif
  2377. diff --context --new-file --recursive ../tcsh-6.02/tc.func.c ./tc.func.c
  2378. *** ../tcsh-6.02/tc.func.c    Wed May 20 04:00:48 1992
  2379. --- ./tc.func.c    Sun Feb 21 01:39:34 1993
  2380. ***************
  2381. *** 277,283 ****
  2382.           tmp = dnormalize(v[k], symlinks == SYM_IGNORE || 
  2383.                      symlinks == SYM_EXPAND);
  2384.           dp = &tmp[Strlen(tmp) - 1];
  2385. !         if (*dp == '/' && dp != tmp)
  2386.   #ifdef apollo
  2387.           if (dp != &tmp[1])
  2388.   #endif /* apollo */
  2389. --- 277,283 ----
  2390.           tmp = dnormalize(v[k], symlinks == SYM_IGNORE || 
  2391.                      symlinks == SYM_EXPAND);
  2392.           dp = &tmp[Strlen(tmp) - 1];
  2393. !         if (is_dirsep(*dp) && dp != tmp)
  2394.   #ifdef apollo
  2395.           if (dp != &tmp[1])
  2396.   #endif /* apollo */
  2397. ***************
  2398. *** 304,310 ****
  2399. --- 304,314 ----
  2400.           xprintf("%s:\n", short2str(tmp));
  2401.           for (cp = tmp, dp = buf; *cp; *dp++ = (*cp++ | QUOTE))
  2402.               continue;
  2403. + #if 0
  2404.           if (dp[-1] != (Char) ('/' | QUOTE))
  2405. + #else
  2406. +         if (! ((dp[-1] & QUOTE) && is_dirsep(dp[-1] & ~QUOTE)))
  2407. + #endif
  2408.               *dp++ = '/';
  2409.           else 
  2410.               dp[-1] &= TRIM;
  2411. ***************
  2412. *** 423,436 ****
  2413.       int     epl, vpl;
  2414.   
  2415.       if ((ep = getenv("EDITOR")) != NULL) {    /* if we have a value */
  2416. !     if ((p = strrchr(ep, '/')) != NULL)     /* if it has a path */
  2417.           ep = p + 1;        /* then we want only the last part */
  2418.       }
  2419.       else 
  2420.       ep = "ed";
  2421.   
  2422.       if ((vp = getenv("VISUAL")) != NULL) {    /* if we have a value */
  2423. !     if ((p = strrchr(vp, '/')) != NULL)     /* and it has a path */
  2424.           vp = p + 1;        /* then we want only the last part */
  2425.       }
  2426.       else 
  2427. --- 427,440 ----
  2428.       int     epl, vpl;
  2429.   
  2430.       if ((ep = getenv("EDITOR")) != NULL) {    /* if we have a value */
  2431. !     if ((p = lastslash(ep)) != NULL)     /* if it has a path */
  2432.           ep = p + 1;        /* then we want only the last part */
  2433.       }
  2434.       else 
  2435.       ep = "ed";
  2436.   
  2437.       if ((vp = getenv("VISUAL")) != NULL) {    /* if we have a value */
  2438. !     if ((p = lastslash(vp)) != NULL)     /* and it has a path */
  2439.           vp = p + 1;        /* then we want only the last part */
  2440.       }
  2441.       else 
  2442. ***************
  2443. *** 450,456 ****
  2444.           continue;
  2445.           *cp = '\0';
  2446.           
  2447. !         if ((cp = strrchr(p, '/')) != NULL)    /* and it has a path */
  2448.           cp = cp + 1;        /* then we want only the last part */
  2449.           else
  2450.           cp = p;            /* else we get all of it */
  2451. --- 454,460 ----
  2452.           continue;
  2453.           *cp = '\0';
  2454.           
  2455. !         if ((cp = lastslash(p)) != NULL)    /* and it has a path */
  2456.           cp = cp + 1;        /* then we want only the last part */
  2457.           else
  2458.           cp = p;            /* else we get all of it */
  2459. ***************
  2460. *** 1393,1405 ****
  2461.       }
  2462.       if (((h = value(STRhome)) != NULL) &&
  2463.       (Strncmp(p = *hm, h, j = Strlen(h)) == 0) &&
  2464. !     (p[j] == '/' || p[j] == '\0')) {
  2465.       *hm = &p[j];
  2466.       return STRNULL;
  2467.       }
  2468.       for (i = 0; i < tlength; i++)
  2469.       if ((Strncmp(p = *hm, tcache[i].home, j = tcache[i].hlen) == 0) &&
  2470. !         (p[j] == '/' || p[j] == '\0')) {
  2471.           *hm = &p[j];
  2472.           return tcache[i].user;
  2473.       }
  2474. --- 1397,1409 ----
  2475.       }
  2476.       if (((h = value(STRhome)) != NULL) &&
  2477.       (Strncmp(p = *hm, h, j = Strlen(h)) == 0) &&
  2478. !     (is_dirsep(p[j]) || p[j] == '\0')) {
  2479.       *hm = &p[j];
  2480.       return STRNULL;
  2481.       }
  2482.       for (i = 0; i < tlength; i++)
  2483.       if ((Strncmp(p = *hm, tcache[i].home, j = tcache[i].hlen) == 0) &&
  2484. !         (is_dirsep(p[j]) || p[j] == '\0')) {
  2485.           *hm = &p[j];
  2486.           return tcache[i].user;
  2487.       }
  2488. ***************
  2489. *** 1459,1466 ****
  2490. --- 1463,1478 ----
  2491.   
  2492.               if ((n = read(fd, tbuf, BUFSIZE)) <= 0)
  2493.               goto eof;
  2494. + #ifdef DOSTEXT
  2495. +         /* we probably should strip the carriage returns, but
  2496. +          * changing them to blanks will work just as well for most cases
  2497. +          */
  2498. +                     for (i = 0; i < n; i++)
  2499. +                         buf[i] = (tbuf[i] == '\r') ? ' ' : tbuf[i];
  2500. + #else
  2501.               for (i = 0; i < n; i++)
  2502.               buf[i] = tbuf[i];
  2503. + #endif
  2504.               p = buf;
  2505.           }
  2506.           n--;
  2507. diff --context --new-file --recursive ../tcsh-6.02/tc.os.c ./tc.os.c
  2508. *** ../tcsh-6.02/tc.os.c    Wed May 20 04:00:50 1992
  2509. --- ./tc.os.c    Sun Feb 21 01:39:28 1993
  2510. ***************
  2511. *** 943,949 ****
  2512.       /* look if we found root yet */
  2513.       if (st_cur.st_ino == st_root.st_ino &&
  2514.           DEV_DEV_COMPARE(st_cur.st_dev, st_root.st_dev)) {
  2515. !         (void) strcpy(pathname, *pathptr != '/' ? "/" : pathptr);
  2516.           return (pathname);
  2517.       }
  2518.   
  2519. --- 943,949 ----
  2520.       /* look if we found root yet */
  2521.       if (st_cur.st_ino == st_root.st_ino &&
  2522.           DEV_DEV_COMPARE(st_cur.st_dev, st_root.st_dev)) {
  2523. !         (void) strcpy(pathname, (! is_dirsep(*pathptr)) ? "/" : pathptr);
  2524.           return (pathname);
  2525.       }
  2526.   
  2527. diff --context --new-file --recursive ../tcsh-6.02/tc.os.h ./tc.os.h
  2528. *** ../tcsh-6.02/tc.os.h    Wed May 20 04:00:50 1992
  2529. --- ./tc.os.h    Sun Feb 21 01:39:34 1993
  2530. ***************
  2531. *** 375,380 ****
  2532. --- 375,381 ----
  2533.   extern int atoi();
  2534.   extern char *ttyname();
  2535.   
  2536. + #ifndef __MINT__
  2537.   # ifndef hpux
  2538.   #  if __GNUC__ != 2
  2539.   extern int abort();
  2540. ***************
  2541. *** 386,391 ****
  2542. --- 387,393 ----
  2543.   extern void abort();
  2544.   extern void qsort();
  2545.   # endif
  2546. + #endif /* __MINT__ */
  2547.   extern void perror();
  2548.   
  2549.   #ifndef NEEDgethostname
  2550. diff --context --new-file --recursive ../tcsh-6.02/tc.prompt.c ./tc.prompt.c
  2551. *** ../tcsh-6.02/tc.prompt.c    Wed May 20 04:00:50 1992
  2552. --- ./tc.prompt.c    Sun Feb 21 01:39:36 1993
  2553. ***************
  2554. *** 257,263 ****
  2555.               else {
  2556.               if ((scp != 'C') && (q = value(STRhome)) &&
  2557.                   Strncmp(buff, q, (k = Strlen(q))) == 0 &&
  2558. !                 (buff[k] == '/' || buff[k] == '\0')) {
  2559.                   buff[--k] = '~';
  2560.                   q = &buff[k];
  2561.               }
  2562. --- 257,263 ----
  2563.               else {
  2564.               if ((scp != 'C') && (q = value(STRhome)) &&
  2565.                   Strncmp(buff, q, (k = Strlen(q))) == 0 &&
  2566. !                 (is_dirsep(buff[k]) || buff[k] == '\0')) {
  2567.                   buff[--k] = '~';
  2568.                   q = &buff[k];
  2569.               }
  2570. ***************
  2571. *** 266,277 ****
  2572.               for (z = q; *z; z++)
  2573.                   continue;    /* find the end */
  2574.               while (j-- > 0) {
  2575. !                 while ((z > q) && (*z != '/'))
  2576.                   z--;    /* back up */
  2577.                   if (j && z > q)
  2578.                   z--;
  2579.               }
  2580. !             if (*z == '/' && z != q)
  2581.                   z++;
  2582.               while (*z) {
  2583.                   *p++ = attributes | *z++;
  2584. --- 266,277 ----
  2585.               for (z = q; *z; z++)
  2586.                   continue;    /* find the end */
  2587.               while (j-- > 0) {
  2588. !                 while ((z > q) && (! is_dirsep(*z)))
  2589.                   z--;    /* back up */
  2590.                   if (j && z > q)
  2591.                   z--;
  2592.               }
  2593. !             if (is_dirsep(*z) && z != q)
  2594.                   z++;
  2595.               while (*z) {
  2596.                   *p++ = attributes | *z++;
  2597. diff --context --new-file --recursive ../tcsh-6.02/tc.sig.c ./tc.sig.c
  2598. *** ../tcsh-6.02/tc.sig.c    Wed May 20 04:00:50 1992
  2599. --- ./tc.sig.c    Sun Feb 21 01:39:36 1993
  2600. ***************
  2601. *** 416,418 ****
  2602. --- 416,439 ----
  2603.       Synch_Cnt++;
  2604.   }
  2605.   #endif /* SIGSYNCH */
  2606. + 
  2607. + #ifdef __MINT__
  2608. + /* MiNT has most BSD signal things, but not sigvec; punt */
  2609. + void
  2610. + mysigvec(sig, new, old)
  2611. +         int sig;
  2612. +         sigvec_t *new, *old;
  2613. + {
  2614. +         void (*oldhandler)();
  2615. + 
  2616. +         if (new) {
  2617. +                 oldhandler = signal(sig, new->sv_handler);
  2618. +         } else {
  2619. +                 oldhandler = signal(sig, SIG_IGN);
  2620. +                 signal(sig, oldhandler);
  2621. +         }
  2622. +         if (old)
  2623. +                 old->sv_handler = oldhandler;
  2624. + }
  2625. + #endif /* __MINT__ */
  2626. + 
  2627. diff --context --new-file --recursive ../tcsh-6.02/tc.sig.h ./tc.sig.h
  2628. *** ../tcsh-6.02/tc.sig.h    Wed May 20 04:00:50 1992
  2629. --- ./tc.sig.h    Sun Feb 21 01:39:38 1993
  2630. ***************
  2631. *** 77,82 ****
  2632. --- 77,90 ----
  2633.   #  define NEEDsignal
  2634.   # endif    /* hpux */
  2635.   
  2636. + # ifdef __MINT__
  2637. + #  define HAVE_SIGVEC
  2638. + typedef struct sigvec {
  2639. +         sigret_t (*sv_handler)();
  2640. + } sigvec_t;
  2641. + extern void mysigvec __P((int, sigvec_t *, sigvec_t *));
  2642. + #endif /* __MINT__ */
  2643. + 
  2644.   # ifndef HAVE_SIGVEC
  2645.   #  define mysigvec(a, b, c)    sigvec(a, b, c)
  2646.   typedef struct sigvec sigvec_t;
  2647. ***************
  2648. *** 120,129 ****
  2649. --- 128,139 ----
  2650.   /*
  2651.    * For 4.2bsd signals.
  2652.    */
  2653. + # ifndef __MINT__
  2654.   # ifdef sigmask
  2655.   #  undef sigmask
  2656.   # endif                /* sigmask */
  2657.   # define    sigmask(s)    (1 << ((s)-1))
  2658. + # endif /* __MINT__ */
  2659.   # ifdef _SEQUENT_
  2660.   #  define     sigpause(a)    bsd_sigpause(a)
  2661.   #  define     signal(a, b)    bsd_signal(a, b)
  2662. diff --context --new-file --recursive ../tcsh-6.02/tw.init.c ./tw.init.c
  2663. *** ../tcsh-6.02/tw.init.c    Wed May 20 04:00:44 1992
  2664. --- ./tw.init.c    Sun Feb 21 01:39:14 1993
  2665. ***************
  2666. *** 248,259 ****
  2667.       struct varent *v = adrof(STRpath);
  2668.       struct varent *recexec = adrof(STRrecognize_only_executables);
  2669.   
  2670.   
  2671.       if (v == NULL) /* if no path */
  2672.       return;
  2673.   
  2674.       for (pv = v->vec; *pv; pv++) {
  2675. !     if (pv[0][0] != '/') {
  2676.           tw_cmd_got |= TW_FL_REL;
  2677.           continue;
  2678.       }
  2679. --- 248,263 ----
  2680.       struct varent *v = adrof(STRpath);
  2681.       struct varent *recexec = adrof(STRrecognize_only_executables);
  2682.   
  2683. + #ifdef __MINT__
  2684. +     struct varent *suffv = adrof(STRsuffixes);
  2685. +     Char **suffpv;
  2686. + #endif
  2687.   
  2688.       if (v == NULL) /* if no path */
  2689.       return;
  2690.   
  2691.       for (pv = v->vec; *pv; pv++) {
  2692. !     if (! is_dirsep(pv[0][0])) {
  2693.           tw_cmd_got |= TW_FL_REL;
  2694.           continue;
  2695.       }
  2696. ***************
  2697. *** 268,273 ****
  2698. --- 272,291 ----
  2699.           name = str2short(dp->d_name);
  2700.           if (dp->d_ino == 0 || (recexec && !executable(dir, name, 0)))
  2701.           continue;
  2702. + 
  2703. + #ifdef __MINT__
  2704. +             {   char *s = rindex(name, '.');
  2705. + 
  2706. +                 if (s && suffv) {
  2707. +                     for (suffpv = suffv->vec; *suffpv; suffpv++) {
  2708. +                         if (!strcmp(s+1, short2str(*suffpv))) {
  2709. +                             *s = 0; break;
  2710. +                         }
  2711. +                     }
  2712. +                 }
  2713. +             }
  2714. + #endif /* __MINT__ */
  2715. + 
  2716.           tw_cmd_add(name);
  2717.       }
  2718.       (void) closedir(dirp);
  2719. ***************
  2720. *** 421,427 ****
  2721.   
  2722.           CLRDIR(tw_cmd_state.dfd)
  2723.   
  2724. !     while (*tw_cmd_state.pathv && tw_cmd_state.pathv[0][0] == '/')
  2725.           tw_cmd_state.pathv++;
  2726.       if ((ptr = *tw_cmd_state.pathv) != 0) {
  2727.           /*
  2728. --- 439,445 ----
  2729.   
  2730.           CLRDIR(tw_cmd_state.dfd)
  2731.   
  2732. !     while (*tw_cmd_state.pathv && is_dirsep(tw_cmd_state.pathv[0][0]))
  2733.           tw_cmd_state.pathv++;
  2734.       if ((ptr = *tw_cmd_state.pathv) != 0) {
  2735.           /*
  2736. diff --context --new-file --recursive ../tcsh-6.02/tw.parse.c ./tw.parse.c
  2737. *** ../tcsh-6.02/tw.parse.c    Wed May 20 04:00:44 1992
  2738. --- ./tw.parse.c    Sun Feb 21 01:39:16 1993
  2739. ***************
  2740. *** 258,264 ****
  2741.   
  2742.       case RECOGNIZE:
  2743.       if (adrof(STRautocorrect)) {
  2744. !         if ((slshp = Strrchr(wordp, '/')) != NULL && slshp[1] != '\0') {
  2745.           SearchNoDirErr = 1;
  2746.           for (bptr = wordp; bptr < slshp; bptr++) {
  2747.               /*
  2748. --- 258,264 ----
  2749.   
  2750.       case RECOGNIZE:
  2751.       if (adrof(STRautocorrect)) {
  2752. !         if ((slshp = Lastslash(word)) != NULL && slshp[1] != '\0') {
  2753.           SearchNoDirErr = 1;
  2754.           for (bptr = wordp; bptr < slshp; bptr++) {
  2755.               /*
  2756. ***************
  2757. *** 341,347 ****
  2758.       items[0] = buffer;
  2759.       items[1] = NULL;
  2760.       ptr = items;
  2761. !     count = (looking == TW_COMMAND && Strchr(wordp, '/') == 0) ? 
  2762.           c_glob(&ptr) : 
  2763.           t_glob(&ptr, looking == TW_COMMAND);
  2764.       if (count > 0) {
  2765. --- 341,347 ----
  2766.       items[0] = buffer;
  2767.       items[1] = NULL;
  2768.       ptr = items;
  2769. !     count = (looking == TW_COMMAND && Hasslash(wordp) == 0) ? 
  2770.           c_glob(&ptr) : 
  2771.           t_glob(&ptr, looking == TW_COMMAND);
  2772.       if (count > 0) {
  2773. ***************
  2774. *** 1140,1146 ****
  2775.       break;
  2776.   
  2777.       case TW_COMMAND:
  2778. !     if (Strchr(word, '/')) {
  2779.           looking = TW_FILE;
  2780.           flags |= TW_EXEC_CHK;
  2781.           flags |= TW_DIR_OK;
  2782. --- 1140,1146 ----
  2783.       break;
  2784.   
  2785.       case TW_COMMAND:
  2786. !     if (Hasslash(word)) {
  2787.           looking = TW_FILE;
  2788.           flags |= TW_EXEC_CHK;
  2789.           flags |= TW_DIR_OK;
  2790. ***************
  2791. *** 1175,1186 ****
  2792.        */
  2793.       flags |= (gpat == 0) ? TW_IGN_OK : TW_PAT_OK;
  2794.   
  2795. !     if ((*word == '~') && (Strchr(word, '/') == NULL)) {
  2796.       looking = TW_LOGNAME;
  2797.       target = name;
  2798.       }
  2799.       else if ((target = Strrchr(name, '$')) != 0 && 
  2800. !          (Strchr(name, '/') == NULL)) {
  2801.       target++;
  2802.       looking = TW_VARIABLE;
  2803.       }
  2804. --- 1175,1186 ----
  2805.        */
  2806.       flags |= (gpat == 0) ? TW_IGN_OK : TW_PAT_OK;
  2807.   
  2808. !     if ((*word == '~') && (Hasslash(word) == NULL)) {
  2809.       looking = TW_LOGNAME;
  2810.       target = name;
  2811.       }
  2812.       else if ((target = Strrchr(name, '$')) != 0 && 
  2813. !          (Hasslash(name) == NULL)) {
  2814.       target++;
  2815.       looking = TW_VARIABLE;
  2816.       }
  2817. ***************
  2818. *** 1232,1242 ****
  2819.       if (isadirectory(exp_dir, name)) {
  2820.           if (exp_dir[0] != '\0' || name[0] != '\0') {
  2821.           catn(dir, name, MAXNAMLEN);
  2822. !         if (dir[Strlen(dir) - 1] != '/')
  2823.               catn(dir, STRslash, MAXNAMLEN);
  2824.           if ((nd = expand_dir(dir, exp_dir, &dir_fd, command)) != 0)
  2825.               return nd;
  2826. !         if (word[Strlen(word) - 1] != '/')
  2827.               catn(word, STRslash, MAXNAMLEN);
  2828.           name[0] = '\0';
  2829.           }
  2830. --- 1232,1242 ----
  2831.       if (isadirectory(exp_dir, name)) {
  2832.           if (exp_dir[0] != '\0' || name[0] != '\0') {
  2833.           catn(dir, name, MAXNAMLEN);
  2834. !         if (! is_dirsep(dir[Strlen(dir) - 1])))
  2835.               catn(dir, STRslash, MAXNAMLEN);
  2836.           if ((nd = expand_dir(dir, exp_dir, &dir_fd, command)) != 0)
  2837.               return nd;
  2838. !         if (! is_dirsep(word[Strlen(word) - 1]))
  2839.               catn(word, STRslash, MAXNAMLEN);
  2840.           name[0] = '\0';
  2841.           }
  2842. ***************
  2843. *** 1342,1348 ****
  2844.   {
  2845.       register Char *p;
  2846.   
  2847. !     p = Strrchr(path, '/');
  2848.       if (p == NULL) {
  2849.       copyn(name, path, MAXNAMLEN);
  2850.       dir[0] = '\0';
  2851. --- 1342,1348 ----
  2852.   {
  2853.       register Char *p;
  2854.   
  2855. !     p = Lastslash(path);
  2856.       if (p == NULL) {
  2857.       copyn(name, path, MAXNAMLEN);
  2858.       dir[0] = '\0';
  2859. ***************
  2860. *** 1417,1423 ****
  2861.   
  2862.       switch (old[0]) {
  2863.       case '~':
  2864. !     for (p = new, o = &old[1]; *o && *o != '/'; *p++ = *o++) 
  2865.           continue;
  2866.       *p = '\0';
  2867.       if (gethdir(new)) {
  2868. --- 1417,1423 ----
  2869.   
  2870.       switch (old[0]) {
  2871.       case '~':
  2872. !     for (p = new, o = &old[1]; *o && (! is_dirsep(*o)); *p++ = *o++) 
  2873.           continue;
  2874.       *p = '\0';
  2875.       if (gethdir(new)) {
  2876. ***************
  2877. *** 1485,1494 ****
  2878.            */
  2879.           for (p = edir; *p; p++)
  2880.           continue;
  2881. !         if (*--p == '/') {
  2882.           for (p = nd; *p; p++)
  2883.               continue;
  2884. !         if (*--p != '/')
  2885.               p = NULL;
  2886.           }
  2887.           for (d = edir, s = nd; (*d++ = *s++) != '\0';)
  2888. --- 1485,1494 ----
  2889.            */
  2890.           for (p = edir; *p; p++)
  2891.           continue;
  2892. !         if (is_dirsep(*--p)) {
  2893.           for (p = nd; *p; p++)
  2894.               continue;
  2895. !         if (! is_dirsep(*--p))
  2896.               p = NULL;
  2897.           }
  2898.           for (d = edir, s = nd; (*d++ = *s++) != '\0';)
  2899. diff --context --new-file --recursive ../tcsh-6.02/tw.spell.c ./tw.spell.c
  2900. *** ../tcsh-6.02/tw.spell.c    Wed May 20 04:00:44 1992
  2901. --- ./tw.spell.c    Sun Feb 21 01:39:16 1993
  2902. ***************
  2903. *** 53,60 ****
  2904.       bool    foundslash = 0;
  2905.       int     retval;
  2906.   
  2907.       for (;;) {
  2908. !     while (*old == '/') {    /* skip '/' */
  2909.           *new++ = *old++;
  2910.           foundslash = 1;
  2911.       }
  2912. --- 53,67 ----
  2913.       bool    foundslash = 0;
  2914.       int     retval;
  2915.   
  2916. + #ifdef DOSFS
  2917. +     /* skip drive specification, if any */
  2918. +     if (*old && old[1] == ':' && is_dirsep(old[2])) {
  2919. +         *new++ = *old++; *new++ = *old++;
  2920. +     }
  2921. + #endif
  2922. + 
  2923.       for (;;) {
  2924. !     while (is_dirsep(*old)) {    /* skip '/' */
  2925.           *new++ = *old++;
  2926.           foundslash = 1;
  2927.       }
  2928. ***************
  2929. *** 73,79 ****
  2930.           if (p < guess + FILSIZ)
  2931.               *p++ = *cp;
  2932.       ws = p;
  2933. !     for (; *old != '/' && *old != '\0'; old++)/* add current file name */
  2934.           if (p < guess + FILSIZ)
  2935.           *p++ = *old;
  2936.       *p = '\0';        /* terminate it */
  2937. --- 80,86 ----
  2938.           if (p < guess + FILSIZ)
  2939.               *p++ = *cp;
  2940.       ws = p;
  2941. !     for (; (! is_dirsep(*old)) && *old != '\0'; old++)/* add current file name */
  2942.           if (p < guess + FILSIZ)
  2943.           *p++ = *old;
  2944.       *p = '\0';        /* terminate it */
  2945. ***************
  2946. *** 84,90 ****
  2947.        */
  2948.       /* (*should* say "looking for directory" whenever '/' is next...) */
  2949.       retval = t_search(guess, p, SPELL, FILSIZ,
  2950. !               looking_for_cmd && (foundslash || *old != '/') ?
  2951.                 TW_COMMAND : TW_ZERO, 1, STRNULL, 0);
  2952.       if (retval >= 4 || retval < 0)
  2953.           return -1;        /* hopeless */
  2954. --- 91,97 ----
  2955.        */
  2956.       /* (*should* say "looking for directory" whenever '/' is next...) */
  2957.       retval = t_search(guess, p, SPELL, FILSIZ,
  2958. !               looking_for_cmd && (foundslash || (! is_dirsep(*old))) ?
  2959.                 TW_COMMAND : TW_ZERO, 1, STRNULL, 0);
  2960.       if (retval >= 4 || retval < 0)
  2961.           return -1;        /* hopeless */
  2962.